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>

void*
CBPeripheral_AllocWithZone(void* zone) {
	return [CBPeripheral allocWithZone:zone];
}
void*
CBPeripheral_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBPeripheral description];
	}
	return ret;

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

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

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

}
void*
CBPeripheral_New() {
	CBPeripheral* ret;
	@autoreleasepool {
		ret = [CBPeripheral new];
	}
	return ret;

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

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

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

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

}
NSUInteger
CBPeripheral_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBPeripheral hash];
	}
	return ret;

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

}
void
CBPeripheral_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBPeripheral setVersion:aVersion];
	}
}
void*
CBPeripheral_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBPeripheral superclass];
	}
	return ret;

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

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

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

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

}
BOOL
CBPeripheral_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral accessInstanceVariablesDirectly];
	}
	return ret;

}
void
CBPeripheral_Load() {
	@autoreleasepool {
		[CBPeripheral load];
	}
}
void*
CBPeripheral_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBPeripheral mutableCopyWithZone:zone];
	}
	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];
	}
}
void*
CBPeripheral_Alloc() {
	return [CBPeripheral alloc];
}
void* _Nonnull
CBPeripheral_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheral classFallbacksForKeyedArchiver];
	}
	return ret;

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

}
NSInteger
CBPeripheral_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBPeripheral version];
	}
	return ret;

}
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
CBPeripheral_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBPeripheral*)o forwardInvocation:anInvocation];
	}
}
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*
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* _Nonnull
CBPeripheral_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
CBPeripheralState
CBPeripheral_inst_State(void* o) {
	CBPeripheralState ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o state];
	}
	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];
	}
}
BOOL
CBPeripheral_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsLessThan:object];
	}
	return ret;

}
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* _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_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void
CBPeripheral_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBPeripheral*)o doesNotRecognizeSelector:aSelector];
	}
}
void
CBPeripheral_inst_ReadRSSI(void* o) {
	@autoreleasepool {
		[(CBPeripheral*)o readRSSI];
	}
}
BOOL
CBPeripheral_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsEqualTo:object];
	}
	return ret;

}
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* _Nonnull
CBPeripheral_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o className];
		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* _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_DiscoverCharacteristics(void* o, void* characteristicUUIDs, void* service) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverCharacteristics:characteristicUUIDs forService:service];
	}
}
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* _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;

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

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

}
void* _Nullable
CBPeripheral_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classForKeyedArchiver];
	}
	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;

}
BOOL
CBPeripheral_inst_CanSendWriteWithoutResponse(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o canSendWriteWithoutResponse];
	}
	return ret;

}
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_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_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBPeripheral*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
CBPeripheral_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingBeginsWith:object];
	}
	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* _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;

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

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

}
void* _Nonnull
CBPeripheral_inst_Identifier(void* o) {
	NSUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o identifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_Services(void* o) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o services];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isGreaterThan: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_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableCopy];
	}
	return ret;

}
void
CBPeripheral_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o setNilValueForKey: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_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o observationInfo];
	}
	return ret;

}
void
CBPeripheral_inst_DiscoverIncludedServices(void* o, void* includedServiceUUIDs, void* service) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverIncludedServices:includedServiceUUIDs forService:service];
	}
}
void
CBPeripheral_inst_SetDelegate(void* o, void* delegate) {
	@autoreleasepool {
		[(CBPeripheral*)o setDelegate:delegate];
	}
}
NSUInteger
CBPeripheral_inst_MaximumWriteValueLengthForType(void* o, CBCharacteristicWriteType type) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o maximumWriteValueLengthForType:type];
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isLessThanOrEqualTo:object];
	}
	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_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_Name(void* o) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o name];
		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_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* _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_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];
	}
}
BOOL
CBPeripheral_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
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;

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

}
void
CBPeripheral_inst_DiscoverDescriptorsForCharacteristic(void* o, void* characteristic) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverDescriptorsForCharacteristic:characteristic];
	}
}
void* _Nonnull
CBPeripheral_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classForCoder];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classForArchiver];
	}
	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];
	}
}
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
CBPeripheral_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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;

}
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;

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

}
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
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];
	}
}
BOOL
CBPeripheral_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isLike:object];
	}
	return ret;

}
void
CBPeripheral_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBPeripheral*)o setObservationInfo:observationInfo];
	}
}
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;

}
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* _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;

}
void
CBPeripheral_inst_DiscoverServices(void* o, void* serviceUUIDs) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverServices:serviceUUIDs];
	}
}
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
CBPeripheral_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBPeripheral*)o dealloc];
	}
}
BOOL
CBPeripheral_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsGreaterThanOrEqualTo: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_ReadValueForDescriptor(void* o, void* descriptor) {
	@autoreleasepool {
		[(CBPeripheral*)o readValueForDescriptor:descriptor];
	}
}
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* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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;

}
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*
CBPeripheral_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o copy];
	}
	return ret;

}
void
CBPeripheral_inst_ReadValueForCharacteristic(void* o, void* characteristic) {
	@autoreleasepool {
		[(CBPeripheral*)o readValueForCharacteristic:characteristic];
	}
}
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_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBPeripheral*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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_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_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_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_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];
	}
}
void* _Nonnull
CBService_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBService classForKeyedUnarchiver];
	}
	return ret;

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

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

}
NSUInteger
CBService_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBService hash];
	}
	return ret;

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

}
void
CBService_Load() {
	@autoreleasepool {
		[CBService load];
	}
}
void*
CBService_New() {
	CBService* ret;
	@autoreleasepool {
		ret = [CBService new];
	}
	return ret;

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

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

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

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

}
void*
CBService_Alloc() {
	return [CBService alloc];
}
void* _Nonnull
CBService_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBService classFallbacksForKeyedArchiver];
	}
	return ret;

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

}
void*
CBService_AllocWithZone(void* zone) {
	return [CBService allocWithZone:zone];
}
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;

}
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_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBService debugDescription];
	}
	return ret;

}
void
CBService_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBService setVersion:aVersion];
	}
}
NSInteger
CBService_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBService version];
	}
	return ret;

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

}
BOOL
CBService_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService accessInstanceVariablesDirectly];
	}
	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;

}
void* _Nonnull
CBService_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o classForCoder];
	}
	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;

}
BOOL
CBService_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isLessThanOrEqualTo:object];
	}
	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* _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;

}
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
CBService_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBService*)o forwardInvocation:anInvocation];
	}
}
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
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* _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;

}
void
CBService_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBService*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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];
	}
}
FourCharCode
CBService_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBService*)o classCode];
	}
	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;

}
void
CBService_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBService*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void*
CBService_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBService*)o copy];
	}
	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
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_Characteristics(void* o) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o characteristics];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _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;

}
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_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isGreaterThan:object];
	}
	return ret;

}
void
CBService_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBService*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nonnull
CBService_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBService_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBService*)o setObservationInfo:observationInfo];
	}
}
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* _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* _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
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* _Nonnull
CBService_inst_Peripheral(void* o) {
	CBPeripheral* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o peripheral];
		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;

}
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];
	}
}
BOOL
CBService_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isEqualTo:object];
	}
	return ret;

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

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

}
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* _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;

}
void* _Nullable
CBService_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o classForKeyedArchiver];
	}
	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* _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* _Nullable
CBService_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingProperties];
		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_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBService*)o setNilValueForKey:key];
	}
}
BOOL
CBService_inst_IsPrimary(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isPrimary];
	}
	return ret;

}
void
CBService_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBService*)o dealloc];
	}
}
void* _Nullable
CBService_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o classForArchiver];
	}
	return ret;

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

}
BOOL
CBService_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingIsEqualTo: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;

}
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
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* _Nullable
CBService_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _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;

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

}
void
CBService_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBService*)o doesNotRecognizeSelector:aSelector];
	}
}
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
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* _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_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableSetValueForKeyPath:keyPath];
		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
CBService_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBService*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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* _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*
CBService_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBService*)o methodSignatureForSelector:aSelector];
		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;

}
void* _Nullable
CBService_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o observationInfo];
	}
	return ret;

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

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

}
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];
	}
}
BOOL
CBService_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o doesContain:object];
	}
	return ret;

}
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;

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

}
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* _Nonnull
CBService_inst_UUID(void* o) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o UUID];
		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;

}
BOOL
CBService_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	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;

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

}
void* _Nullable
CBService_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

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

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

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

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

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

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

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

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

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

}
void*
CBCharacteristic_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCharacteristic mutableCopyWithZone:zone];
	}
	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_AllocWithZone(void* zone) {
	return [CBCharacteristic allocWithZone:zone];
}
void* _Nonnull
CBCharacteristic_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCharacteristic keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

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

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

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

}
void
CBCharacteristic_Load() {
	@autoreleasepool {
		[CBCharacteristic load];
	}
}
void
CBCharacteristic_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBCharacteristic setVersion:aVersion];
	}
}
void* _Nonnull
CBCharacteristic_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCharacteristic classFallbacksForKeyedArchiver];
	}
	return ret;

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

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

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

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

}
NSInteger
CBCharacteristic_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBCharacteristic version];
	}
	return ret;

}
void*
CBCharacteristic_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableCopy];
	}
	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* _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;

}
void* _Nullable
CBCharacteristic_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o replacementObjectForCoder:aCoder];
		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;

}
BOOL
CBCharacteristic_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o doesContain: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_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBCharacteristic*)o setScriptingProperties:scriptingProperties];
	}
}
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;

}
BOOL
CBCharacteristic_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingEndsWith: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* _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_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o setNilValueForKey:key];
	}
}
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*
CBCharacteristic_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o methodSignatureForSelector:aSelector];
		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;

}
BOOL
CBCharacteristic_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsGreaterThan:object];
	}
	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;

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

}
void
CBCharacteristic_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBCharacteristic*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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];
	}
}
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* _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;

}
BOOL
CBCharacteristic_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isLessThan:object];
	}
	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_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classForArchiver];
	}
	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_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableArrayValueForKey:key];
		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_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _Nonnull
CBCharacteristic_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _Nonnull
CBCharacteristic_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nonnull
CBCharacteristic_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o autoContentAccessingProxy];
		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;

}
BOOL
CBCharacteristic_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isEqualTo:object];
	}
	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_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_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsLessThan:object];
	}
	return ret;

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

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

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

}
void* _Nullable
CBCharacteristic_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o observationInfo];
	}
	return ret;

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

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

}
void
CBCharacteristic_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBCharacteristic*)o dealloc];
	}
}
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;

}
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* _Nonnull
CBCharacteristic_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classForCoder];
	}
	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;

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

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

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

}
void
CBCharacteristic_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBCharacteristic*)o doesNotRecognizeSelector:aSelector];
	}
}
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_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

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

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

}
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_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBCharacteristic*)o setObservationInfo:observationInfo];
	}
}
void* _Nullable
CBCharacteristic_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o awakeAfterUsingCoder:aDecoder];
		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_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isCaseInsensitiveLike: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* _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_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isLike:object];
	}
	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;

}
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];
	}
}
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_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_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_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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_Descriptors(void* o) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o descriptors];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isLessThanOrEqualTo:object];
	}
	return ret;

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

}
void
CBCharacteristic_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBCharacteristic*)o forwardInvocation:anInvocation];
	}
}
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_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

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

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

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

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

}
void*
CBDescriptor_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBDescriptor class];
	}
	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_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor resolveInstanceMethod:sel];
	}
	return ret;

}
void*
CBDescriptor_AllocWithZone(void* zone) {
	return [CBDescriptor allocWithZone:zone];
}
BOOL
CBDescriptor_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor accessInstanceVariablesDirectly];
	}
	return ret;

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

}
NSInteger
CBDescriptor_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBDescriptor version];
	}
	return ret;

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

}
void
CBDescriptor_Load() {
	@autoreleasepool {
		[CBDescriptor load];
	}
}
void*
CBDescriptor_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBDescriptor debugDescription];
	}
	return ret;

}
void
CBDescriptor_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBDescriptor setVersion:aVersion];
	}
}
void*
CBDescriptor_Alloc() {
	return [CBDescriptor alloc];
}
void*
CBDescriptor_New() {
	CBDescriptor* ret;
	@autoreleasepool {
		ret = [CBDescriptor new];
	}
	return ret;

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

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

}
NSUInteger
CBDescriptor_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBDescriptor hash];
	}
	return ret;

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

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

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

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

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

}
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
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* _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
CBDescriptor_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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_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_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* _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* _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;

}
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];
	}
}
FourCharCode
CBDescriptor_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classCode];
	}
	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
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_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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];
	}
}
void* _Nonnull
CBDescriptor_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o observationInfo];
	}
	return ret;

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

}
void
CBDescriptor_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBDescriptor*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nonnull
CBDescriptor_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classForCoder];
	}
	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* _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_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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
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
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];
	}
}
BOOL
CBDescriptor_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingContains:object];
	}
	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* _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* _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;

}
BOOL
CBDescriptor_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsGreaterThan:object];
	}
	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* _Nonnull
CBDescriptor_inst_Characteristic(void* o) {
	CBCharacteristic* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o characteristic];
		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;

}
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_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o doesContain:object];
	}
	return ret;

}
BOOL
CBDescriptor_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isCaseInsensitiveLike: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, void* array) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
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];
	}
}
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
CBDescriptor_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o setNilValueForKey:key];
	}
}
void
CBDescriptor_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBDescriptor*)o setObservationInfo:observationInfo];
	}
}
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_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingEndsWith:object];
	}
	return ret;

}
void
CBDescriptor_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBDescriptor*)o dealloc];
	}
}
void* _Nonnull
CBDescriptor_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isGreaterThan:object];
	}
	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;

}
void* _Nullable
CBDescriptor_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o awakeAfterUsingCoder:aDecoder];
		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;

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

}
void* _Nullable
CBDescriptor_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o replacementObjectForCoder:aCoder];
		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*
CBDescriptor_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	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_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o forwardingTargetForSelector:aSelector];
		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;

}
void
CBDescriptor_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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];
	}
}
BOOL
CBDescriptor_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsLessThanOrEqualTo:object];
	}
	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* _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;

}
BOOL
CBDescriptor_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isEqualTo:object];
	}
	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
CBDescriptor_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBDescriptor*)o forwardInvocation:anInvocation];
	}
}
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
CBDescriptor_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBDescriptor*)o setScriptingProperties:scriptingProperties];
	}
}
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;

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

}
BOOL
CBDescriptor_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingBeginsWith:object];
	}
	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* _Nonnull
CBDescriptor_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o className];
		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
CBDescriptor_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBDescriptor*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
CBDescriptor_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableCopy];
	}
	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* _Nonnull
CBDescriptor_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void* _Nullable
CBDescriptor_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classForArchiver];
	}
	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;

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

}
NSUInteger
CBUUID_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBUUID hash];
	}
	return ret;

}
void*
CBUUID_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBUUID class];
	}
	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* _Nonnull
CBUUID_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID classFallbacksForKeyedArchiver];
	}
	return ret;

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

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

}
NSInteger
CBUUID_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBUUID version];
	}
	return ret;

}
void* _Nonnull
CBUUID_UUIDWithNSUUID(void* theUUID) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID UUIDWithNSUUID:theUUID];
		if(ret != nil) { [ret retain]; }
	}
	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* _Nonnull
CBUUID_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID classForKeyedUnarchiver];
	}
	return ret;

}
void*
CBUUID_New() {
	CBUUID* ret;
	@autoreleasepool {
		ret = [CBUUID new];
	}
	return ret;

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

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

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

}
void*
CBUUID_AllocWithZone(void* zone) {
	return [CBUUID allocWithZone:zone];
}
BOOL
CBUUID_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID accessInstanceVariablesDirectly];
	}
	return ret;

}
void
CBUUID_Load() {
	@autoreleasepool {
		[CBUUID load];
	}
}
void*
CBUUID_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBUUID debugDescription];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

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

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

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

}
void* _Nonnull
CBUUID_UUIDWithData(void* theData) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID UUIDWithData:theData];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

}
void
CBUUID_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBUUID setVersion:aVersion];
	}
}
void*
CBUUID_Alloc() {
	return [CBUUID alloc];
}
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_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsLessThanOrEqualTo: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;

}
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* _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;

}
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* _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_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*
CBUUID_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableCopy];
	}
	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_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;

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

}
void* _Nullable
CBUUID_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
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;

}
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;

}
BOOL
CBUUID_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isGreaterThanOrEqualTo:object];
	}
	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
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;

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

}
void*
CBUUID_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o copy];
	}
	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_Data(void* o) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o data];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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* _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_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
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* _Nonnull
CBUUID_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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
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
CBUUID_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBUUID*)o forwardInvocation:anInvocation];
	}
}
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* _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;

}
void* _Nullable
CBUUID_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o observationInfo];
	}
	return ret;

}
void
CBUUID_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBUUID*)o setObservationInfo:observationInfo];
	}
}
void
CBUUID_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBUUID*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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_Dealloc(void* o) {
	@autoreleasepool {
		[(CBUUID*)o dealloc];
	}
}
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* _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_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];
	}
}
void
CBUUID_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBUUID*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nonnull
CBUUID_inst_UUIDString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o UUIDString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

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

}
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;

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

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

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

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

}
void
CBUUID_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBUUID*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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;

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

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

}
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_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	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* _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_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBUUID*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
CBUUID_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsEqualTo:object];
	}
	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* _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;

}
BOOL
CBUUID_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingBeginsWith:object];
	}
	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];
	}
}
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;

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

}
BOOL
CBUUID_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsLessThan:object];
	}
	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* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
BOOL
CBUUID_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsGreaterThan:object];
	}
	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_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_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
CBUUID_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBUUID*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
CBUUID_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isNotEqualTo:object];
	}
	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
CBUUID_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBUUID*)o setNilValueForKey:key];
	}
}
void* _Nonnull
CBUUID_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o classForCoder];
	}
	return ret;

}
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_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isLessThan:object];
	}
	return ret;

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

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

}
void
NSAutoreleasePool_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSAutoreleasePool setVersion:aVersion];
	}
}
NSInteger
NSAutoreleasePool_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool version];
	}
	return ret;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}
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*
NSAutoreleasePool_AllocWithZone(void* zone) {
	NSAutoreleasePool* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool allocWithZone:zone];
	}
	return ret;

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

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

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

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

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

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

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

}
void* _Nullable
NSAutoreleasePool_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classForKeyedArchiver];
	}
	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* _Nullable
NSAutoreleasePool_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
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_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setNilValueForKey:key];
	}
}
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* _Nullable
NSAutoreleasePool_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o observationInfo];
	}
	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* _Nullable
NSAutoreleasePool_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classForCoder];
	}
	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* _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_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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;

}
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_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_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setScriptingProperties:scriptingProperties];
	}
}
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];
	}
}
void* _Nullable
NSAutoreleasePool_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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_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;

}
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
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* _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* _Nullable
NSAutoreleasePool_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classForArchiver];
	}
	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];
	}
}
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
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];
	}
}
BOOL
NSAutoreleasePool_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isLike:object];
	}
	return ret;

}
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_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
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_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isLessThan:object];
	}
	return ret;

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

}
BOOL
NSAutoreleasePool_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsGreaterThan:object];
	}
	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_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsEqualTo:object];
	}
	return ret;

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

}
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_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*
NSAutoreleasePool_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableCopy];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isGreaterThan: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_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
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];
	}
}
void* _Nonnull
NSAutoreleasePool_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsLessThanOrEqualTo:object];
	}
	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_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingEndsWith:object];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o doesContain: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;

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

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

}
void
NSAutoreleasePool_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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;

}
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_AddObject(void* o, void* anObject) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o addObject:anObject];
	}
}
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;

}
void
NSAutoreleasePool_inst_Drain(void* o) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o drain];
	}
}
BOOL
NSAutoreleasePool_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isLessThanOrEqualTo:object];
	}
	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_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setObservationInfo:observationInfo];
	}
}
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* _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;

}
BOOL
NSAutoreleasePool_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isNotEqualTo: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
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
NSAutoreleasePool_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nonnull
NSAutoreleasePool_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o forwardInvocation:anInvocation];
	}
}
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* _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* _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;

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

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

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

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

}
NSInteger
CBPeripheralManager_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBPeripheralManager version];
	}
	return ret;

}
void*
CBPeripheralManager_New() {
	CBPeripheralManager* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager new];
	}
	return ret;

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

}
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];
	}
}
void*
CBPeripheralManager_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

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

}
void
CBPeripheralManager_Load() {
	@autoreleasepool {
		[CBPeripheralManager load];
	}
}
void* _Nonnull
CBPeripheralManager_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheralManager keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
BOOL
CBPeripheralManager_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager accessInstanceVariablesDirectly];
	}
	return ret;

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

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

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

}
CBPeripheralManagerAuthorizationStatus
CBPeripheralManager_AuthorizationStatus() {
	CBPeripheralManagerAuthorizationStatus ret;
	@autoreleasepool {
		ret = [CBPeripheralManager authorizationStatus];
	}
	return ret;

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

}
void*
CBPeripheralManager_AllocWithZone(void* zone) {
	return [CBPeripheralManager allocWithZone:zone];
}
BOOL
CBPeripheralManager_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager conformsToProtocol:protocol];
	}
	return ret;

}
NSUInteger
CBPeripheralManager_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBPeripheralManager hash];
	}
	return ret;

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

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

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

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

}
void
CBPeripheralManager_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBPeripheralManager setVersion:aVersion];
	}
}
void*
CBPeripheralManager_Alloc() {
	return [CBPeripheralManager alloc];
}
void* _Nonnull
CBPeripheralManager_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheralManager classFallbacksForKeyedArchiver];
	}
	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_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingContains:object];
	}
	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, void* array) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
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* _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
CBPeripheralManager_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setObservationInfo:observationInfo];
	}
}
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;

}
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_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*
CBPeripheralManager_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o copy];
	}
	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*
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_UpdateValue(void* o, void* value, void* characteristic, void* centrals) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o updateValue:value forCharacteristic:characteristic onSubscribedCentrals:centrals];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o awakeAfterUsingCoder:aDecoder];
		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];
	}
}
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
CBPeripheralManager_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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* _Nonnull
CBPeripheralManager_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
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_SetDelegate(void* o, void* delegate) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setDelegate:delegate];
	}
}
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_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;

}
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_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_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setNilValueForKey:key];
	}
}
void
CBPeripheralManager_inst_AddService(void* o, void* service) {
	@autoreleasepool {
		[(CBPeripheralManager*)o addService:service];
	}
}
void* _Nonnull
CBPeripheralManager_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsLessThanOrEqualTo: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_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_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setScriptingProperties:scriptingProperties];
	}
}
void
CBPeripheralManager_inst_StartAdvertising(void* o, void* advertisementData) {
	@autoreleasepool {
		[(CBPeripheralManager*)o startAdvertising:advertisementData];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsLessThan:object];
	}
	return ret;

}
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* _Nonnull
CBPeripheralManager_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void
CBPeripheralManager_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBPeripheralManager*)o forwardInvocation:anInvocation];
	}
}
void* _Nullable
CBPeripheralManager_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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;

}
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;

}
BOOL
CBPeripheralManager_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isGreaterThanOrEqualTo:object];
	}
	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];
	}
}
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;

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

}
BOOL
CBPeripheralManager_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o doesContain: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* _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;

}
BOOL
CBPeripheralManager_inst_IsAdvertising(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isAdvertising];
	}
	return ret;

}
void
CBPeripheralManager_inst_RemoveService(void* o, void* service) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeService:service];
	}
}
void
CBPeripheralManager_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _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_RemoveAllServices(void* o) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeAllServices];
	}
}
void
CBPeripheralManager_inst_SetDesiredConnectionLatency(void* o, CBPeripheralManagerConnectionLatency latency, void* central) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setDesiredConnectionLatency:latency forCentral:central];
	}
}
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
CBPeripheralManager_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBPeripheralManager*)o dealloc];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingEndsWith:object];
	}
	return ret;

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

}
void
CBPeripheralManager_inst_RespondToRequest(void* o, void* request, CBATTError result) {
	@autoreleasepool {
		[(CBPeripheralManager*)o respondToRequest:request withResult:result];
	}
}
BOOL
CBPeripheralManager_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isGreaterThan:object];
	}
	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;

}
FourCharCode
CBPeripheralManager_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o classCode];
	}
	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;

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

}
BOOL
CBPeripheralManager_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingBeginsWith:object];
	}
	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* _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* _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
CBPeripheralManager_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBPeripheralManager*)o doesNotRecognizeSelector:aSelector];
	}
}
CBManagerState
CBPeripheralManager_inst_State(void* o) {
	CBManagerState ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o state];
	}
	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;

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

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

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

}
void
CBPeripheralManager_inst_StopAdvertising(void* o) {
	@autoreleasepool {
		[(CBPeripheralManager*)o stopAdvertising];
	}
}
void* _Nonnull
CBPeripheralManager_inst_Init(void* o) {
	CBPeripheralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o init];
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isLessThanOrEqualTo: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_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_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isEqualTo:object];
	}
	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;

}
void* _Nullable
CBPeripheralManager_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o observationInfo];
	}
	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_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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];
	}
}
void*
CBPeripheralManager_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableCopy];
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsEqualTo:object];
	}
	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];
	}
}
BOOL
NSArray_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray isSubclassOfClass:aClass];
	}
	return ret;

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

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

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

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

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

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

}
void*
NSArray_Alloc() {
	return [NSArray alloc];
}
void
NSArray_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSArray setVersion:aVersion];
	}
}
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* _Nonnull
NSArray_ArrayWithObjects(void* firstObj, void* object) {
	NSObject** arr = object;
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray arrayWithObjects:firstObj , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

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

}
void*
NSArray_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSArray copyWithZone:zone];
	}
	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_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray resolveInstanceMethod:sel];
	}
	return ret;

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

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

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

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

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

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

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

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

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

}
void* _Nullable
NSArray_ArrayWithContentsOfURL(void* url) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [NSArray arrayWithContentsOfURL:url];
		if(ret != nil) { [ret retain]; }
	}
	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;

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

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

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

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

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

}
void
NSArray_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSArray*)o forwardInvocation:anInvocation];
	}
}
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_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingEndsWith:object];
	}
	return ret;

}
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_ObjectAtIndexedSubscript(void* o, NSUInteger idx) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectAtIndexedSubscript:idx];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _Nonnull
NSArray_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o toManyRelationshipKeys];
		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;

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

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

}
BOOL
NSArray_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingContains: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];
	}
}
void* _Nonnull
NSArray_inst_ObjectEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectEnumerator];
		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* _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*
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_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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_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
NSArray_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSArray*)o dealloc];
	}
}
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;

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

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

}
BOOL
NSArray_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	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_PathsMatchingExtensions(void* o, void* filterTypes) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o pathsMatchingExtensions:filterTypes];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
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;

}
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;

}
BOOL
NSArray_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsEqualTo:object];
	}
	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;

}
void* _Nonnull
NSArray_inst_SortedArrayHint(void* o) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o sortedArrayHint];
		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* _Nonnull
NSArray_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

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

}
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* _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_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* _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;

}
BOOL
NSArray_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isGreaterThanOrEqualTo:object];
	}
	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;

}
BOOL
NSArray_inst_WriteToURLAtomically(void* o, void* url, BOOL atomically) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o writeToURL:url atomically:atomically];
	}
	return ret;

}
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;

}
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;

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

}
BOOL
NSArray_inst_WriteToFileAtomically(void* o, void* path, BOOL useAuxiliaryFile) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o writeToFile:path atomically:useAuxiliaryFile];
	}
	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* _Nonnull
NSArray_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void
NSArray_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSArray*)o setNilValueForKey:key];
	}
}
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* _Nonnull
NSArray_inst_InitWithObjects(void* o, void* firstObj, void* object) {
	NSObject** arr = object;
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithObjects:firstObj , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
	}
	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;

}
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
NSArray_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSArray*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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;

}
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* _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;

}
void
NSArray_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSArray*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
NSArray_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsLessThan: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* _Nullable
NSArray_inst_InitWithContentsOfFile(void* o, void* path) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithContentsOfFile:path];
	}
	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
NSArray_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSArray*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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* _Nullable
NSArray_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o classForArchiver];
	}
	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
NSArray_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSArray*)o setObservationInfo:observationInfo];
	}
}
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];
	}
}
BOOL
NSArray_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isLessThanOrEqualTo:object];
	}
	return ret;

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

}
void
NSArray_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSArray*)o doesNotRecognizeSelector:aSelector];
	}
}
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
NSArray_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSArray*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
BOOL
NSArray_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isEqualTo:object];
	}
	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* _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;

}
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
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
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_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void* _Nonnull
NSArray_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableCopyWithZone:zone];
	}
	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];
	}
}
NSUInteger
NSArray_inst_Count(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o count];
	}
	return ret;

}
void* _Nullable
NSArray_inst_InitWithContentsOfURL(void* o, void* url) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithContentsOfURL:url];
	}
	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* _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;

}
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* _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
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_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isLessThan:object];
	}
	return ret;

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

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

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

}
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_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];
	}
}
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_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret 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_Init(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o init];
	}
	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*
NSArray_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableCopy];
	}
	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* _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_ObjectsAtIndexes(void* o, void* indexes) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectsAtIndexes:indexes];
		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* _Nullable
NSArray_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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;

}
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_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* _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* _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* _Nullable
NSArray_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsGreaterThan:object];
	}
	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* _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_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSMutableArray superclass];
	}
	return ret;

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

}
void
NSMutableArray_Load() {
	@autoreleasepool {
		[NSMutableArray load];
	}
}
void*
NSMutableArray_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSMutableArray copyWithZone:zone];
	}
	return ret;

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

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

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

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

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

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

}
void*
NSMutableArray_AllocWithZone(void* zone) {
	return [NSMutableArray allocWithZone:zone];
}
void* _Nonnull
NSMutableArray_ArrayWithArray(void* array) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithArray:array];
		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* _Nonnull
NSMutableArray_ArrayWithObjects(void* firstObj, void* object) {
	NSObject** arr = object;
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithObjects:firstObj , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

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

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

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

}
BOOL
NSMutableArray_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray supportsSecureCoding];
	}
	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_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];
	}
}
BOOL
NSMutableArray_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray isSubclassOfClass:aClass];
	}
	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;

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

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

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

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

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

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

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

}
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
NSMutableArray_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o setNilValueForKey:key];
	}
}
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_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_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];
	}
}
void* _Nonnull
NSMutableArray_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableCopyWithZone:zone];
	}
	return ret;

}
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_SetObjectAtIndexedSubscript(void* o, void* obj, NSUInteger idx) {
	@autoreleasepool {
		[(NSMutableArray*)o setObject:obj atIndexedSubscript:idx];
	}
}
FourCharCode
NSMutableArray_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classCode];
	}
	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];
	}
}
BOOL
NSMutableArray_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isLike:object];
	}
	return ret;

}
BOOL
NSMutableArray_inst_WriteToFileAtomically(void* o, void* path, BOOL useAuxiliaryFile) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o writeToFile:path atomically:useAuxiliaryFile];
	}
	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;

}
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];
	}
}
BOOL
NSMutableArray_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsGreaterThan:object];
	}
	return ret;

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

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

}
void
NSMutableArray_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSMutableArray*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
NSMutableArray_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isEqualTo:object];
	}
	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;

}
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];
	}
}
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* _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;

}
BOOL
NSMutableArray_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsGreaterThanOrEqualTo: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_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
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* _Nullable
NSMutableArray_inst_InitWithContentsOfFile(void* o, void* path) {
	NSMutableArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithContentsOfFile:path];
	}
	return ret;

}
void
NSMutableArray_inst_RemoveLastObject(void* o) {
	@autoreleasepool {
		[(NSMutableArray*)o removeLastObject];
	}
}
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_WriteToURLAtomically(void* o, void* url, BOOL atomically) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o writeToURL:url atomically:atomically];
	}
	return ret;

}
void
NSMutableArray_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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];
	}
}
void* _Nonnull
NSMutableArray_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _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_ObjectAtIndexedSubscript(void* o, NSUInteger idx) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o objectAtIndexedSubscript:idx];
		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* _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* _Nullable
NSMutableArray_inst_FirstObject(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o firstObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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;

}
BOOL
NSMutableArray_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsLessThan:object];
	}
	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_InsertObjectsAtIndexes(void* o, void* objects, void* indexes) {
	@autoreleasepool {
		[(NSMutableArray*)o insertObjects:objects atIndexes:indexes];
	}
}
BOOL
NSMutableArray_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingEndsWith:object];
	}
	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* _Nonnull
NSMutableArray_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o doesContain:object];
	}
	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_ExchangeObjectAtIndexWithObjectAtIndex(void* o, NSUInteger idx1, NSUInteger idx2) {
	@autoreleasepool {
		[(NSMutableArray*)o exchangeObjectAtIndex:idx1 withObjectAtIndex:idx2];
	}
}
void
NSMutableArray_inst_SetArray(void* o, void* otherArray) {
	@autoreleasepool {
		[(NSMutableArray*)o setArray:otherArray];
	}
}
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
NSMutableArray_inst_RemoveObjectsAtIndexes(void* o, void* indexes) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectsAtIndexes:indexes];
	}
}
void* _Nonnull
NSMutableArray_inst_InitWithCapacity(void* o, NSUInteger numItems) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithCapacity:numItems];
	}
	return ret;

}
BOOL
NSMutableArray_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isNotEqualTo:object];
	}
	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
NSMutableArray_inst_SortUsingSelector(void* o, void* comparator) {
	@autoreleasepool {
		[(NSMutableArray*)o sortUsingSelector:comparator];
	}
}
void* _Nonnull
NSMutableArray_inst_Init(void* o) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o init];
	}
	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* _Nonnull
NSMutableArray_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classForCoder];
	}
	return ret;

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

}
void
NSMutableArray_inst_RemoveObjectAtIndex(void* o, NSUInteger index) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectAtIndex:index];
	}
}
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_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_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableOrderedSetValueForKey:key];
		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_ValueForKey(void* o, void* key) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

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

}
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;

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

}
BOOL
NSMutableArray_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isCaseInsensitiveLike:object];
	}
	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;

}
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
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_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* _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_FilterUsingPredicate(void* o, void* predicate) {
	@autoreleasepool {
		[(NSMutableArray*)o filterUsingPredicate:predicate];
	}
}
BOOL
NSMutableArray_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingContains:object];
	}
	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_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nonnull
NSMutableArray_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o copyWithZone:zone];
	}
	return ret;

}
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* _Nullable
NSMutableArray_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_InsertObjectAtIndex(void* o, void* anObject, NSUInteger index) {
	@autoreleasepool {
		[(NSMutableArray*)o insertObject:anObject atIndex:index];
	}
}
void
NSMutableArray_inst_RemoveObjectsInArray(void* o, void* otherArray) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectsInArray:otherArray];
	}
}
void
NSMutableArray_inst_RemoveAllObjects(void* o) {
	@autoreleasepool {
		[(NSMutableArray*)o removeAllObjects];
	}
}
void* _Nullable
NSMutableArray_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o objectSpecifier];
		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* _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_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o observationInfo];
	}
	return ret;

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

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

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

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

}
void
NSMutableArray_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSMutableArray*)o setObservationInfo:observationInfo];
	}
}
void
NSMutableArray_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSMutableArray*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
NSMutableArray_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o copy];
	}
	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* _Nullable
NSMutableArray_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classForKeyedArchiver];
	}
	return ret;

}
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_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_RemoveObjectsInRange(void* o, NSRange range) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectsInRange:range];
	}
}
void
NSMutableArray_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSMutableArray*)o forwardInvocation:anInvocation];
	}
}
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;

}
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* _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
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_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;

}
void
NSMutableArray_inst_ReplaceObjectsAtIndexesWithObjects(void* o, void* indexes, void* objects) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceObjectsAtIndexes:indexes withObjects:objects];
	}
}
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
NSMutableArray_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSMutableArray*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
BOOL
NSMutableArray_inst_ContainsObject(void* o, void* anObject) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o containsObject:anObject];
	}
	return ret;

}
void
NSMutableArray_inst_AddObject(void* o, void* anObject) {
	@autoreleasepool {
		[(NSMutableArray*)o addObject:anObject];
	}
}
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;

}
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_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_ReplaceObjectAtIndexWithObject(void* o, NSUInteger index, void* anObject) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceObjectAtIndex:index withObject:anObject];
	}
}
BOOL
NSMutableArray_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
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* _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;

}
void
NSMutableArray_inst_AddObjectsFromArray(void* o, void* otherArray) {
	@autoreleasepool {
		[(NSMutableArray*)o addObjectsFromArray:otherArray];
	}
}
void* _Nonnull
NSMutableArray_inst_ReverseObjectEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o reverseObjectEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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* _Nullable
NSMutableArray_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingProperties];
		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* _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;

}
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* _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* _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* _Nullable
NSMutableArray_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _Nonnull
NSMutableArray_inst_InitWithObjects(void* o, void* firstObj, void* object) {
	NSObject** arr = object;
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithObjects:firstObj , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
	}
	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;

}
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_ComponentsJoinedByString(void* o, void* separator) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o componentsJoinedByString:separator];
		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_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;

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

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

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

}
void* _Nonnull
NSEnumerator_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSEnumerator keyPathsForValuesAffectingValueForKey:key];
	}
	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;

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

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

}
void
NSEnumerator_Load() {
	@autoreleasepool {
		[NSEnumerator load];
	}
}
void
NSEnumerator_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSEnumerator setVersion:aVersion];
	}
}
void*
NSEnumerator_New() {
	NSEnumerator* ret;
	@autoreleasepool {
		ret = [NSEnumerator new];
	}
	return ret;

}
void*
NSEnumerator_AllocWithZone(void* zone) {
	return [NSEnumerator allocWithZone:zone];
}
BOOL
NSEnumerator_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
NSEnumerator_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSEnumerator debugDescription];
	}
	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];
	}
}
void*
NSEnumerator_Alloc() {
	return [NSEnumerator alloc];
}
BOOL
NSEnumerator_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator resolveClassMethod:sel];
	}
	return ret;

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

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

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

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

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

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

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

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

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

}
void* _Nullable
NSEnumerator_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret 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;

}
BOOL
NSEnumerator_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isNotEqualTo:object];
	}
	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
NSEnumerator_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSEnumerator*)o dealloc];
	}
}
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
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];
	}
}
BOOL
NSEnumerator_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isEqualTo: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_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isGreaterThanOrEqualTo:object];
	}
	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_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* _Nonnull
NSEnumerator_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o classForArchiver];
	}
	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;

}
void
NSEnumerator_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o setNilValueForKey:key];
	}
}
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;

}
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
NSEnumerator_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSEnumerator*)o setObservationInfo:observationInfo];
	}
}
void* _Nullable
NSEnumerator_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSEnumerator*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
NSEnumerator_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsEqualTo:object];
	}
	return ret;

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

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

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

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

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

}
void* _Nullable
NSEnumerator_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o classForKeyedArchiver];
	}
	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_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* _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;

}
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];
	}
}
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* _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;

}
void* _Nonnull
NSEnumerator_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o attributeKeys];
		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_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_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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_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_AllObjects(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o allObjects];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isLike:object];
	}
	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_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_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingEndsWith:object];
	}
	return ret;

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

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

}
void*
NSEnumerator_inst_Init(void* o) {
	NSEnumerator* ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o init];
	}
	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* _Nullable
NSEnumerator_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o observationInfo];
	}
	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];
	}
}
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* _Nonnull
NSEnumerator_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isCaseInsensitiveLike:object];
	}
	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* _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_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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_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];
	}
}
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_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* _Nullable
NSEnumerator_inst_NextObject(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o nextObject];
		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
NSEnumerator_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSEnumerator*)o forwardInvocation:anInvocation];
	}
}
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;

}
BOOL
NSEnumerator_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsLessThan:object];
	}
	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;

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

}
BOOL
NSEnumerator_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingContains:object];
	}
	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_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

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

}
BOOL
NSEnumerator_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsGreaterThan:object];
	}
	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];
	}
}
BOOL
NSEnumerator_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingBeginsWith:object];
	}
	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_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*
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;

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

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

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

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

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

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

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

}
void*
NSUUID_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSUUID debugDescription];
		if(ret != nil) { [ret retain]; }
	}
	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];
	}
}
NSInteger
NSUUID_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSUUID version];
	}
	return ret;

}
void*
NSUUID_AllocWithZone(void* zone) {
	return [NSUUID allocWithZone:zone];
}
BOOL
NSUUID_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID resolveClassMethod:sel];
	}
	return ret;

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

}
void
NSUUID_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSUUID setVersion:aVersion];
	}
}
void*
NSUUID_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSUUID superclass];
	}
	return ret;

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

}
void
NSUUID_Load() {
	@autoreleasepool {
		[NSUUID load];
	}
}
void* _Nonnull
NSUUID_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSUUID classFallbacksForKeyedArchiver];
	}
	return ret;

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

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

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

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

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

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

}
BOOL
NSUUID_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isGreaterThanOrEqualTo: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];
	}
}
void
NSUUID_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSUUID*)o dealloc];
	}
}
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;

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

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

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

}
void* _Nonnull
NSUUID_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o copyWithZone:zone];
	}
	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* _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;

}
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_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;

}
void
NSUUID_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSUUID*)o removeValueAtIndex:index fromPropertyWithKey: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
NSUUID_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSUUID*)o setObservationInfo:observationInfo];
	}
}
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];
	}
}
FourCharCode
NSUUID_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classCode];
	}
	return ret;

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

}
BOOL
NSUUID_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingBeginsWith:object];
	}
	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_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* _Nonnull
NSUUID_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o toOneRelationshipKeys];
		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* _Nonnull
NSUUID_inst_Init(void* o) {
	NSUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o init];
	}
	return ret;

}
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* _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* _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
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* _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_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
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* _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_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
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* _Nonnull
NSUUID_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classForCoder];
	}
	return ret;

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

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

}
void* _Nullable
NSUUID_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classForKeyedArchiver];
	}
	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* _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;

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

}
BOOL
NSUUID_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingIsGreaterThan:object];
	}
	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*
NSUUID_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableCopy];
	}
	return ret;

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

}
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
NSUUID_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSUUID*)o setNilValueForKey:key];
	}
}
void* _Nullable
NSUUID_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o observationInfo];
	}
	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_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

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

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

}
void
NSUUID_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSUUID*)o doesNotRecognizeSelector:aSelector];
	}
}
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*
NSUUID_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSUUID*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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* _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* _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_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o replacementObjectForCoder:aCoder];
		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* _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
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];
	}
}
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_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingIsLessThanOrEqualTo:object];
	}
	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
NSUUID_inst_GetUUIDBytes(void* o, void* uuid) {
	@autoreleasepool {
		[(NSUUID*)o getUUIDBytes:uuid];
	}
}
void* _Nullable
NSUUID_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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;

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

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

}
void
NSUUID_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSUUID*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
BOOL
NSUUID_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isCaseInsensitiveLike:object];
	}
	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;

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

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

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

}
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];
	}
}
void
NSUUID_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSUUID*)o setScriptingProperties:scriptingProperties];
	}
}
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;

}
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* _Nonnull
NSUUID_inst_UUIDString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o UUIDString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void
CBAttribute_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBAttribute setVersion:aVersion];
	}
}
void*
CBAttribute_AllocWithZone(void* zone) {
	return [CBAttribute allocWithZone:zone];
}
void* _Nonnull
CBAttribute_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBAttribute classForKeyedUnarchiver];
	}
	return ret;

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

}
void
CBAttribute_Load() {
	@autoreleasepool {
		[CBAttribute load];
	}
}
BOOL
CBAttribute_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute conformsToProtocol:protocol];
	}
	return ret;

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

}
void*
CBAttribute_New() {
	CBAttribute* ret;
	@autoreleasepool {
		ret = [CBAttribute new];
	}
	return ret;

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

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

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

}
NSInteger
CBAttribute_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBAttribute version];
	}
	return ret;

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

}
BOOL
CBAttribute_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute accessInstanceVariablesDirectly];
	}
	return ret;

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

}
void*
CBAttribute_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBAttribute class];
	}
	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_Alloc() {
	return [CBAttribute alloc];
}
void* _Nonnull
CBAttribute_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBAttribute classFallbacksForKeyedArchiver];
	}
	return ret;

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

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

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

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

}
NSUInteger
CBAttribute_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBAttribute hash];
	}
	return ret;

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

}
BOOL
CBAttribute_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsLessThan:object];
	}
	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
CBAttribute_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBAttribute*)o forwardInvocation:anInvocation];
	}
}
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* _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];
	}
}
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];
	}
}
BOOL
CBAttribute_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsEqualTo:object];
	}
	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* _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_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingEndsWith:object];
	}
	return ret;

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

}
void* _Nullable
CBAttribute_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o observationInfo];
	}
	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* _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* _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;

}
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
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_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;

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

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

}
BOOL
CBAttribute_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsGreaterThan:object];
	}
	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;

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

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

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

}
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* _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;

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

}
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* _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_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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];
	}
}
BOOL
CBAttribute_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingBeginsWith:object];
	}
	return ret;

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

}
void
CBAttribute_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBAttribute*)o dealloc];
	}
}
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* _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;

}
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;

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

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

}
void
CBAttribute_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBAttribute*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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];
	}
}
BOOL
CBAttribute_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

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

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

}
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];
	}
}
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* _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_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* _Nonnull
CBAttribute_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o className];
		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* _Nullable
CBAttribute_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBAttribute_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableCopy];
	}
	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;

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

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

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

}
void
CBAttribute_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o setNilValueForKey:key];
	}
}
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
CBAttribute_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBAttribute*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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;

}
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_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;

}
BOOL
CBAttribute_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isLessThan:object];
	}
	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_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_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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];
	}
}
BOOL
CBAttribute_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isEqualTo:object];
	}
	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;

}
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];
	}
}
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];
	}
}
void* _Nullable
CBAttribute_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBAttribute*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
NSDictionary_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary conformsToProtocol:protocol];
	}
	return ret;

}
void*
NSDictionary_New() {
	NSDictionary* ret;
	@autoreleasepool {
		ret = [NSDictionary new];
	}
	return ret;

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

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

}
void
NSDictionary_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSDictionary setVersion:aVersion];
	}
}
void* _Nullable
NSDictionary_DictionaryWithContentsOfFile(void* path) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithContentsOfFile:path];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_DictionaryWithContentsOfURL(void* url) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithContentsOfURL:url];
		if(ret != nil) { [ret retain]; }
	}
	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;

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

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

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

}
NSUInteger
NSDictionary_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSDictionary hash];
	}
	return ret;

}
BOOL
NSDictionary_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary automaticallyNotifiesObserversForKey:key];
	}
	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* _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;

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

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

}
void
NSDictionary_Load() {
	@autoreleasepool {
		[NSDictionary load];
	}
}
void*
NSDictionary_AllocWithZone(void* zone) {
	return [NSDictionary allocWithZone:zone];
}
void*
NSDictionary_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSDictionary mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
NSDictionary_SharedKeySetForKeys(void* keys) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary sharedKeySetForKeys:keys];
	}
	return ret;

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

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

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

}
void* _Nonnull
NSDictionary_DictionaryWithObjectsAndKeys(void* firstObject, void* object) {
	NSObject** arr = object;
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithObjectsAndKeys:firstObject , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_Dictionary() {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionary];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

}
void*
NSDictionary_Alloc() {
	return [NSDictionary alloc];
}
BOOL
NSDictionary_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary isSubclassOfClass:aClass];
	}
	return ret;

}
BOOL
NSDictionary_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary supportsSecureCoding];
	}
	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_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary accessInstanceVariablesDirectly];
	}
	return ret;

}
BOOL
NSDictionary_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary instancesRespondToSelector:aSelector];
	}
	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];
	}
}
NSInteger
NSDictionary_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSDictionary version];
	}
	return ret;

}
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;

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

}
NSUInteger
NSDictionary_inst_FileSystemFileNumber(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileSystemFileNumber];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o autoContentAccessingProxy];
		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;

}
OSType
NSDictionary_inst_FileHFSTypeCode(void* o) {
	OSType ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileHFSTypeCode];
	}
	return ret;

}
BOOL
NSDictionary_inst_FileIsImmutable(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileIsImmutable];
	}
	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;

}
void
NSDictionary_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSDictionary_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
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_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_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_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_InitWithCoder(void* o, void* aDecoder) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithCoder:aDecoder];
	}
	return ret;

}
void
NSDictionary_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSDictionary*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
NSDictionary_inst_FileOwnerAccountID(void* o) {
	NSNumber* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileOwnerAccountID];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
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* _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_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isNotEqualTo:object];
	}
	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* _Nullable
NSDictionary_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_KeyEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o keyEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
unsigned long long
NSDictionary_inst_FileSize(void* o) {
	unsigned long long ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileSize];
	}
	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* _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;

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

}
BOOL
NSDictionary_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsEqualTo: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];
	}
}
BOOL
NSDictionary_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classForKeyedArchiver];
	}
	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_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o copyWithZone:zone];
	}
	return ret;

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

}
void
NSDictionary_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSDictionary*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o inverseForRelationshipKey:relationshipKey];
		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;

}
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_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o copy];
	}
	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;

}
BOOL
NSDictionary_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsLessThanOrEqualTo:object];
	}
	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_KeysSortedByValueUsingSelector(void* o, void* comparator) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o keysSortedByValueUsingSelector:comparator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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
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];
	}
}
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_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isLessThan:object];
	}
	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];
	}
}
BOOL
NSDictionary_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingBeginsWith:object];
	}
	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
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* _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* _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_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableOrderedSetValueForKeyPath:keyPath];
		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_FileExtensionHidden(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileExtensionHidden];
	}
	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
NSDictionary_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSDictionary*)o setScriptingProperties:scriptingProperties];
	}
}
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_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingEndsWith:object];
	}
	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;

}
void* _Nullable
NSDictionary_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classForArchiver];
	}
	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* _Nullable
NSDictionary_inst_FileModificationDate(void* o) {
	NSDate* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileModificationDate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
NSUInteger
NSDictionary_inst_FilePosixPermissions(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o filePosixPermissions];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_InitWithContentsOfURL(void* o, void* url) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithContentsOfURL:url];
	}
	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;

}
BOOL
NSDictionary_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsGreaterThan:object];
	}
	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* _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_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_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
NSDictionary_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o setNilValueForKey:key];
	}
}
BOOL
NSDictionary_inst_FileIsAppendOnly(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileIsAppendOnly];
	}
	return ret;

}
OSType
NSDictionary_inst_FileHFSCreatorCode(void* o) {
	OSType ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileHFSCreatorCode];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_InitWithObjectsAndKeys(void* o, void* firstObject, void* object) {
	NSObject** arr = object;
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithObjectsAndKeys:firstObject , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
	}
	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
NSDictionary_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSDictionary*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
NSDictionary_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableCopy];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classForCoder];
	}
	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;

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

}
BOOL
NSDictionary_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isLike:object];
	}
	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;

}
BOOL
NSDictionary_inst_IsEqualToDictionary(void* o, void* otherDictionary) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isEqualToDictionary:otherDictionary];
	}
	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;

}
BOOL
NSDictionary_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsLessThan: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;

}
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_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
NSInteger
NSDictionary_inst_FileSystemNumber(void* o) {
	NSInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileSystemNumber];
	}
	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* _Nonnull
NSDictionary_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o toManyRelationshipKeys];
		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* _Nullable
NSDictionary_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o observationInfo];
	}
	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_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;

}
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
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* _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;

}
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_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isGreaterThan:object];
	}
	return ret;

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

}
void* _Nullable
NSDictionary_inst_InitWithContentsOfFile(void* o, void* path) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithContentsOfFile:path];
	}
	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;

}
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_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSDictionary*)o forwardInvocation:anInvocation];
	}
}
NSUInteger
NSDictionary_inst_Count(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o count];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_FileCreationDate(void* o) {
	NSDate* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileCreationDate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_WriteToFileAtomically(void* o, void* path, BOOL useAuxiliaryFile) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o writeToFile:path atomically:useAuxiliaryFile];
	}
	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;

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

}
void
NSDictionary_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSDictionary*)o dealloc];
	}
}
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_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o dictionaryWithValuesForKeys:keys];
		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;

}
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;

}
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;

}
BOOL
NSDictionary_inst_WriteToURLAtomically(void* o, void* url, BOOL atomically) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o writeToURL:url atomically:atomically];
	}
	return ret;

}
void
NSDictionary_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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*
NSObject_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSObject class];
	}
	return ret;

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

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

}
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_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject instancesRespondToSelector:aSelector];
	}
	return ret;

}
NSInteger
NSObject_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSObject version];
	}
	return ret;

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

}
BOOL
NSObject_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject accessInstanceVariablesDirectly];
	}
	return ret;

}
void
NSObject_Load() {
	@autoreleasepool {
		[NSObject load];
	}
}
void*
NSObject_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSObject copyWithZone:zone];
	}
	return ret;

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

}
void
NSObject_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSObject setVersion:aVersion];
	}
}
void*
NSObject_Alloc() {
	return [NSObject alloc];
}
BOOL
NSObject_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject resolveInstanceMethod:sel];
	}
	return ret;

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

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

}
BOOL
NSObject_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject conformsToProtocol:protocol];
	}
	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];
	}
}
BOOL
NSObject_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject automaticallyNotifiesObserversForKey:key];
	}
	return ret;

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

}
void*
NSObject_AllocWithZone(void* zone) {
	return [NSObject allocWithZone:zone];
}
void*
NSObject_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSObject description];
	}
	return ret;

}
void*
NSObject_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSObject instanceMethodSignatureForSelector:aSelector];
	}
	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* _Nonnull
NSObject_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o className];
		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* _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;

}
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*
NSObject_inst_Retain(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSObject*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isEqualTo: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*
NSObject_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSObject*)o debugDescription];
		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_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o doesContain:object];
	}
	return ret;

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

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

}
void
NSObject_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSObject*)o setNilValueForKey:key];
	}
}
BOOL
NSObject_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o respondsToSelector:aSelector];
	}
	return ret;

}
void*
NSObject_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSObject*)o superclass];
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsLessThanOrEqualTo:object];
	}
	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* _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;

}
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*
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*
NSObject_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSObject*)o class];
	}
	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*
NSObject_inst_Init(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o init];
	}
	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_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o inverseForRelationshipKey:relationshipKey];
		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* _Nullable
NSObject_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isProxy];
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	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* _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;

}
BOOL
NSObject_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isMemberOfClass:aClass];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o observationInfo];
	}
	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;

}
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];
	}
}
BOOL
NSObject_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingContains:object];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o replacementObjectForCoder:aCoder];
		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_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSObject*)o setScriptingProperties:scriptingProperties];
	}
}
void*
NSObject_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableCopy];
	}
	return ret;

}
void
NSObject_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSObject*)o setObservationInfo:observationInfo];
	}
}
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;

}
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
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* _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;

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

}
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_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isLike:object];
	}
	return ret;

}
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
NSObject_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSObject*)o dealloc];
	}
}
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_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSObject*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsEqualTo:object];
	}
	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;

}
BOOL
NSObject_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsLessThan:object];
	}
	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_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isLessThan:object];
	}
	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_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o conformsToProtocol:aProtocol];
	}
	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
NSObject_inst_Release(void* o) {
	@autoreleasepool {
		[(NSObject*)o release];
	}
}
BOOL
NSObject_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isEqual:object];
	}
	return ret;

}
NSUInteger
NSObject_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSObject*)o hash];
	}
	return ret;

}
void
NSObject_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSObject*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
BOOL
NSObject_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isCaseInsensitiveLike:object];
	}
	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];
	}
}
void* _Nonnull
NSObject_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o classForCoder];
	}
	return ret;

}
NSUInteger
NSObject_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSObject*)o retainCount];
	}
	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];
	}
}
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;

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

}
BOOL
NSObject_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsGreaterThan:object];
	}
	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* _Nonnull
NSObject_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSObject*)o forwardInvocation:anInvocation];
	}
}
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];
	}
}
BOOL
NSObject_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingBeginsWith:object];
	}
	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];
	}
}
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_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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
NSObject_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSObject*)o doesNotRecognizeSelector:aSelector];
	}
}
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;

}
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_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(NSObject*)o zone];
	}
	return ret;

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

}
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_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableOrderedSetValueForKey: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;

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

}
BOOL
NSObject_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isKindOfClass:aClass];
	}
	return ret;

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

}
void*
NSData_AllocWithZone(void* zone) {
	return [NSData allocWithZone:zone];
}
void* _Nonnull
NSData_Data() {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData data];
		if(ret != nil) { [ret 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_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* _Nonnull
NSData_DataWithData(void* data) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData dataWithData:data];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

}
NSUInteger
NSData_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSData hash];
	}
	return ret;

}
BOOL
NSData_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData isSubclassOfClass:aClass];
	}
	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*
NSData_New() {
	NSData* ret;
	@autoreleasepool {
		ret = [NSData new];
	}
	return ret;

}
NSInteger
NSData_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSData version];
	}
	return ret;

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

}
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_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSData copyWithZone:zone];
	}
	return ret;

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

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

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

}
BOOL
NSData_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
NSData_Alloc() {
	return [NSData alloc];
}
BOOL
NSData_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData supportsSecureCoding];
	}
	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*
NSData_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSData debugDescription];
	}
	return ret;

}
void
NSData_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSData setVersion:aVersion];
	}
}
void*
NSData_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSData class];
	}
	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;

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

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

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

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

}
void
NSData_Load() {
	@autoreleasepool {
		[NSData load];
	}
}
void* _Nonnull
NSData_inst_InitWithData(void* o, void* data) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithData:data];
	}
	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* _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* _Nullable
NSData_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSData_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableCopy];
	}
	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;

}
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;

}
void* _Nonnull
NSData_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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* _Nonnull
NSData_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o classForCoder];
	}
	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;

}
BOOL
NSData_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isGreaterThanOrEqualTo:object];
	}
	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
NSData_inst_Release(void* o) {
	@autoreleasepool {
		[(NSData*)o release];
	}
}
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;

}
BOOL
NSData_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o conformsToProtocol:aProtocol];
	}
	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_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;

}
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_SubdataWithRange(void* o, NSRange range) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o subdataWithRange:range];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSData*)o setNilValueForKey:key];
	}
}
BOOL
NSData_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isLessThan: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
NSData_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSData*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
NSData_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingProperties];
		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* _Nonnull
NSData_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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_Autorelease(void* o) {
	NSData* ret;
	@autoreleasepool {
		ret = [(NSData*)o autorelease];
		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;

}
NSUInteger
NSData_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSData*)o retainCount];
	}
	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];
	}
}
void* _Nullable
NSData_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o classForKeyedArchiver];
	}
	return ret;

}
void
NSData_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSData*)o forwardInvocation:anInvocation];
	}
}
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* _Nullable
NSData_inst_InitWithBase64EncodedDataOptions(void* o, void* base64Data, NSDataBase64DecodingOptions options) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithBase64EncodedData:base64Data options:options];
	}
	return ret;

}
BOOL
NSData_inst_IsEqualToData(void* o, void* other) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isEqualToData:other];
	}
	return ret;

}
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*
NSData_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSData*)o debugDescription];
		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];
	}
}
BOOL
NSData_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsGreaterThanOrEqualTo: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];
	}
}
BOOL
NSData_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o respondsToSelector:aSelector];
	}
	return ret;

}
void*
NSData_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSData*)o superclass];
	}
	return ret;

}
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_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;

}
BOOL
NSData_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingContains:object];
	}
	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;

}
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;

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

}
void*
NSData_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(NSData*)o zone];
	}
	return ret;

}
void* _Nonnull
NSData_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o classDescription];
		if (ret != nil && ret != o) { [ret 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;

}
BOOL
NSData_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isLessThanOrEqualTo:object];
	}
	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_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isEqual:object];
	}
	return ret;

}
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
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];
	}
}
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* _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_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;

}
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];
	}
}
FourCharCode
NSData_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSData*)o classCode];
	}
	return ret;

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

}
NSUInteger
NSData_inst_Length(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSData*)o length];
	}
	return ret;

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

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

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

}
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;

}
const void* _Nonnull
NSData_inst_Bytes(void* o) {
	const void* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o bytes];
	}
	return ret;

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

}
void*
NSData_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSData*)o class];
	}
	return ret;

}
BOOL
NSData_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isLike:object];
	}
	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;

}
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;

}
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
NSData_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSData*)o setScriptingProperties:scriptingProperties];
	}
}
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];
	}
}
BOOL
NSData_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingBeginsWith:object];
	}
	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* _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;

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

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

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

}
BOOL
NSData_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isKindOfClass:aClass];
	}
	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;

}
void* _Nullable
NSData_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o replacementObjectForCoder:aCoder];
		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* _Nonnull
NSData_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o className];
		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_Self(void* o) {
	NSData* ret;
	@autoreleasepool {
		ret = [(NSData*)o self];
		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];
	}
}
BOOL
NSData_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsEqualTo:object];
	}
	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*
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];
	}
}
BOOL
NSData_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsLessThan:object];
	}
	return ret;

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

}
void
NSData_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSData*)o doesNotRecognizeSelector:aSelector];
	}
}
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
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
NSData_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSData*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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;

}
BOOL
NSData_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isEqualTo:object];
	}
	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_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSData*)o setObservationInfo:observationInfo];
	}
}
void* _Nonnull
NSData_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableCopyWithZone:zone];
	}
	return ret;

}
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;

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

}
void* _Nullable
NSData_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o observationInfo];
	}
	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];
	}
}
BOOL
NSData_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isProxy];
	}
	return ret;

}
BOOL
NSData_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isMemberOfClass:aClass];
	}
	return ret;

}
NSUInteger
NSData_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSData*)o hash];
	}
	return ret;

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

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

}
void*
CBManager_AllocWithZone(void* zone) {
	return [CBManager allocWithZone:zone];
}
BOOL
CBManager_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager accessInstanceVariablesDirectly];
	}
	return ret;

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

}
NSUInteger
CBManager_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBManager hash];
	}
	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];
	}
}
BOOL
CBManager_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager automaticallyNotifiesObserversForKey:key];
	}
	return ret;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}
BOOL
CBManager_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o conformsToProtocol:aProtocol];
	}
	return ret;

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

}
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;

}
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];
	}
}
void*
CBManager_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBManager*)o debugDescription];
		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* _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;

}
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];
	}
}
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;

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

}
BOOL
CBManager_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o respondsToSelector:aSelector];
	}
	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;

}
BOOL
CBManager_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isEqual:object];
	}
	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*
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*
CBManager_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(CBManager*)o zone];
	}
	return ret;

}
void
CBManager_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBManager*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsEqualTo:object];
	}
	return ret;

}
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_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_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
CBManager_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
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;

}
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_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];
	}
}
void*
CBManager_inst_PerformSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBManager*)o performSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBManager_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBManager*)o performSelector:aSelector withObject:object];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBManager_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBManager*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
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_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_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];
	}
}
void* _Nullable
CBManager_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o classForKeyedArchiver];
	}
	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_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBManager*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
FourCharCode
CBManager_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBManager*)o classCode];
	}
	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;

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

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

}
void*
CBManager_inst_Self(void* o) {
	CBManager* ret;
	@autoreleasepool {
		ret = [(CBManager*)o self];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
BOOL
CBManager_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isNotEqualTo: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*
CBManager_inst_Description(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBManager*)o description];
		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* _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* _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*
CBManager_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(CBManager*)o class];
	}
	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;

}
BOOL
CBManager_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isMemberOfClass:aClass];
	}
	return ret;

}
void
CBManager_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBManager*)o setScriptingProperties:scriptingProperties];
	}
}
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;

}
BOOL
CBManager_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isLike:object];
	}
	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* _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_Retain(void* o) {
	CBManager* ret;
	@autoreleasepool {
		ret = [(CBManager*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

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

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

}
void
CBManager_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBManager*)o forwardInvocation:anInvocation];
	}
}
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*
CBManager_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBManager*)o copy];
	}
	return ret;

}
void
CBManager_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBManager*)o setNilValueForKey:key];
	}
}
BOOL
CBManager_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isCaseInsensitiveLike:object];
	}
	return ret;

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

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

}
BOOL
CBManager_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingBeginsWith: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];
	}
}
BOOL
CBManager_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsLessThanOrEqualTo:object];
	}
	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];
	}
}
BOOL
CBManager_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isLessThan:object];
	}
	return ret;

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

}
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;

}
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];
	}
}
NSUInteger
CBManager_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBManager*)o hash];
	}
	return ret;

}
NSUInteger
CBManager_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBManager*)o retainCount];
	}
	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_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];
	}
}
BOOL
CBManager_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingContains:object];
	}
	return ret;

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

}
BOOL
CBManager_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isKindOfClass:aClass];
	}
	return ret;

}
void
CBManager_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBManager*)o dealloc];
	}
}
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
CBManager_inst_Release(void* o) {
	@autoreleasepool {
		[(CBManager*)o release];
	}
}
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];
	}
}
CBManagerState
CBManager_inst_State(void* o) {
	CBManagerState ret;
	@autoreleasepool {
		ret = [(CBManager*)o state];
	}
	return ret;

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

}
void
CBManager_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBManager*)o setObservationInfo:observationInfo];
	}
}
void*
CBManager_inst_Autorelease(void* o) {
	CBManager* ret;
	@autoreleasepool {
		ret = [(CBManager*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
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;

}
BOOL
CBManager_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isProxy];
	}
	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* _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_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBManager*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nullable
CBManager_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o classForArchiver];
	}
	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];
	}
}
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*
CBCentralManager_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBCentralManager class];
	}
	return ret;

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

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

}
BOOL
CBCentralManager_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager accessInstanceVariablesDirectly];
	}
	return ret;

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

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

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

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

}
void*
CBCentralManager_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCentralManager mutableCopyWithZone:zone];
	}
	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];
	}
}
BOOL
CBCentralManager_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager automaticallyNotifiesObserversForKey:key];
	}
	return ret;

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

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

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

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

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

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

}
void*
CBCentralManager_New() {
	CBCentralManager* ret;
	@autoreleasepool {
		ret = [CBCentralManager new];
	}
	return ret;

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

}
void
CBCentralManager_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBCentralManager setVersion:aVersion];
	}
}
void* _Nonnull
CBCentralManager_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentralManager classForKeyedUnarchiver];
	}
	return ret;

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

}
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_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];
	}
}
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;

}
BOOL
CBCentralManager_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isKindOfClass:aClass];
	}
	return ret;

}
BOOL
CBCentralManager_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o respondsToSelector:aSelector];
	}
	return ret;

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

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

}
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;

}
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
CBCentralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBCentralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
BOOL
CBCentralManager_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o conformsToProtocol:aProtocol];
	}
	return ret;

}
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* _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;

}
void*
CBCentralManager_inst_Description(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o description];
		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_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o copy];
	}
	return ret;

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

}
CBManagerState
CBCentralManager_inst_State(void* o) {
	CBManagerState ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o state];
	}
	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;

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

}
void* _Nullable
CBCentralManager_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classForKeyedArchiver];
	}
	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* _Nullable
CBCentralManager_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classForArchiver];
	}
	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_IsScanning(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isScanning];
	}
	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];
	}
}
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;

}
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_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBCentralManager*)o doesNotRecognizeSelector:aSelector];
	}
}
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_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(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_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o zone];
	}
	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*
CBCentralManager_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o superclass];
	}
	return ret;

}
void
CBCentralManager_inst_StopScan(void* o) {
	@autoreleasepool {
		[(CBCentralManager*)o stopScan];
	}
}
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
CBCentralManager_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBCentralManager*)o setScriptingProperties:scriptingProperties];
	}
}
void
CBCentralManager_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBCentralManager*)o dealloc];
	}
}
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_ScanForPeripheralsWithServices(void* o, void* serviceUUIDs, void* options) {
	@autoreleasepool {
		[(CBCentralManager*)o scanForPeripheralsWithServices:serviceUUIDs options:options];
	}
}
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;

}
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* _Nonnull
CBCentralManager_inst_Init(void* o) {
	CBCentralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o init];
	}
	return ret;

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

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

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

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

}
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* _Nonnull
CBCentralManager_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void
CBCentralManager_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o setNilValueForKey:key];
	}
}
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* _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* _Nonnull
CBCentralManager_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
CBCentralManager_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o retainCount];
	}
	return ret;

}
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;

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

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

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

}
BOOL
CBCentralManager_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isCaseInsensitiveLike:object];
	}
	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
CBCentralManager_inst_AddObserverForKeyPathOptionsContext(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBCentralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void*
CBCentralManager_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableCopy];
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isProxy];
	}
	return ret;

}
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_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o valueForKey:key];
		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_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBCentralManager*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void
CBCentralManager_inst_Release(void* o) {
	@autoreleasepool {
		[(CBCentralManager*)o release];
	}
}
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_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
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* _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_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_SetDelegate(void* o, void* delegate) {
	@autoreleasepool {
		[(CBCentralManager*)o setDelegate:delegate];
	}
}
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;

}
void* _Nullable
CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(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_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o doesContain:object];
	}
	return ret;

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

}
BOOL
CBCentralManager_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isLessThanOrEqualTo:object];
	}
	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* _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* _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;

}
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_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*
CBCentralManager_inst_Self(void* o) {
	CBCentralManager* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o self];
		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* _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_CancelPeripheralConnection(void* o, void* peripheral) {
	@autoreleasepool {
		[(CBCentralManager*)o cancelPeripheralConnection:peripheral];
	}
}
void
CBCentralManager_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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
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];
	}
}
BOOL
CBCentralManager_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
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
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*
CBCentralManager_inst_Autorelease(void* o) {
	CBCentralManager* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isMemberOfClass:aClass];
	}
	return ret;

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

}
BOOL
CBCentralManager_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingContains: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];
	}
}
FourCharCode
CBCentralManager_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classCode];
	}
	return ret;

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

}
NSUInteger
CBCentralManager_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o hash];
	}
	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];
	}
}
void*
CBCentralManager_inst_PerformSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o performSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void*
CBCentralManager_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
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_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_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) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
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_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableOrderedSetValueForKey: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_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingEndsWith:object];
	}
	return ret;

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

}
void*
CBCentral_Alloc() {
	return [CBCentral alloc];
}
void*
CBCentral_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBCentral superclass];
	}
	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_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_Load() {
	@autoreleasepool {
		[CBCentral load];
	}
}
void* _Nonnull
CBCentral_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentral classForKeyedUnarchiver];
	}
	return ret;

}
void*
CBCentral_AllocWithZone(void* zone) {
	return [CBCentral allocWithZone:zone];
}
void*
CBCentral_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBCentral class];
	}
	return ret;

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

}
void
CBCentral_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBCentral setVersion:aVersion];
	}
}
BOOL
CBCentral_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
CBCentral_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral conformsToProtocol:protocol];
	}
	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;

}
BOOL
CBCentral_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral accessInstanceVariablesDirectly];
	}
	return ret;

}
NSInteger
CBCentral_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBCentral version];
	}
	return ret;

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

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

}
NSUInteger
CBCentral_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBCentral hash];
	}
	return ret;

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

}
void*
CBCentral_New() {
	CBCentral* ret;
	@autoreleasepool {
		ret = [CBCentral new];
	}
	return ret;

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

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

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

}
void*
CBCentral_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(CBCentral*)o class];
	}
	return ret;

}
BOOL
CBCentral_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isMemberOfClass:aClass];
	}
	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;

}
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];
	}
}
NSUInteger
CBCentral_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBCentral*)o retainCount];
	}
	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* _Nonnull
CBCentral_inst_Identifier(void* o) {
	NSUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o identifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

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

}
void* _Nonnull
CBCentral_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classForCoder];
	}
	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* _Nullable
CBCentral_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o observationInfo];
	}
	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* _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;

}
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_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isLike:object];
	}
	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;

}
BOOL
CBCentral_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isProxy];
	}
	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_Release(void* o) {
	@autoreleasepool {
		[(CBCentral*)o release];
	}
}
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;

}
BOOL
CBCentral_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isEqualTo:object];
	}
	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_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBCentral*)o setObservationInfo:observationInfo];
	}
}
void* _Nullable
CBCentral_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classForKeyedArchiver];
	}
	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;

}
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_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsGreaterThan:object];
	}
	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;

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

}
BOOL
CBCentral_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsLessThanOrEqualTo:object];
	}
	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*
CBCentral_inst_Description(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
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];
	}
}
BOOL
CBCentral_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsLessThan:object];
	}
	return ret;

}
BOOL
CBCentral_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isLessThan:object];
	}
	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_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBCentral*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
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;

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

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

}
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_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];
	}
}
FourCharCode
CBCentral_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classCode];
	}
	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
CBCentral_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentral*)o setNilValueForKey:key];
	}
}
void* _Nullable
CBCentral_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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];
	}
}
void*
CBCentral_inst_Autorelease(void* o) {
	CBCentral* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
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
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];
	}
}
BOOL
CBCentral_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	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];
	}
}
void*
CBCentral_inst_Self(void* o) {
	CBCentral* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o self];
		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_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o replacementObjectForKeyedArchiver:archiver];
		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;

}
void
CBCentral_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBCentral*)o dealloc];
	}
}
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* _Nullable
CBCentral_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o awakeAfterUsingCoder:aDecoder];
		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_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_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* _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;

}
BOOL
CBCentral_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isLessThanOrEqualTo:object];
	}
	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;

}
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_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o debugDescription];
		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;

}
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* _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;

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

}
void
CBCentral_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBCentral*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isNotEqualTo:object];
	}
	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* _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;

}
void
CBCentral_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentral*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
CBCentral_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isEqual:object];
	}
	return ret;

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

}
void*
CBCentral_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o zone];
	}
	return ret;

}
void*
CBCentral_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(CBCentral*)o superclass];
	}
	return ret;

}
BOOL
CBCentral_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isKindOfClass:aClass];
	}
	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* _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
CBCentral_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBCentral*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
CBCentral_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o conformsToProtocol:aProtocol];
	}
	return ret;

}
void
CBCentral_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBCentral*)o doesNotRecognizeSelector:aSelector];
	}
}
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;

}
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;

}
NSUInteger
CBCentral_inst_MaximumUpdateValueLength(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBCentral*)o maximumUpdateValueLength];
	}
	return ret;

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

}
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_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o copy];
	}
	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* _Nonnull
NSString_WritableTypeIdentifiersForItemProvider() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString writableTypeIdentifiersForItemProvider];
	}
	return ret;

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

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

}
void
NSString_Load() {
	@autoreleasepool {
		[NSString load];
	}
}
void*
NSString_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSString superclass];
	}
	return ret;

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

}
void* _Nonnull
NSString_LocalizedStringWithFormat(void* format, void* object) {
	NSObject** arr = object;
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString localizedStringWithFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
	}
	return ret;

}
void*
NSString_New() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSString new];
	}
	return ret;

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

}
NSUInteger
NSString_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSString hash];
	}
	return ret;

}
void* _Nullable
NSString_StringWithUTF8String(void* nullTerminatedCString) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithUTF8String:nullTerminatedCString];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
const void* _Nonnull
NSString_AvailableStringEncodings() {
	const NSStringEncoding* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString availableStringEncodings];
	}
	return ret;

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

}
void* _Nonnull
NSString_String() {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString string];
		if(ret != nil) { [ret 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_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString conformsToProtocol:protocol];
	}
	return ret;

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

}
NSItemProviderRepresentationVisibility
NSString_ItemProviderVisibilityForRepresentationWithTypeIdentifier(void* typeIdentifier) {
	NSItemProviderRepresentationVisibility ret;
	@autoreleasepool {
		ret = [NSString itemProviderVisibilityForRepresentationWithTypeIdentifier:typeIdentifier];
	}
	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*
NSString_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSString class];
	}
	return ret;

}
BOOL
NSString_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString accessInstanceVariablesDirectly];
	}
	return ret;

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

}
NSInteger
NSString_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSString version];
	}
	return ret;

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

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

}
void
NSString_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSString setVersion:aVersion];
	}
}
NSStringEncoding
NSString_DefaultCStringEncoding() {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [NSString defaultCStringEncoding];
	}
	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_PathWithComponents(void* components) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString pathWithComponents:components];
	}
	return ret;

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

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

}
void*
NSString_AllocWithZone(void* zone) {
	return [NSString allocWithZone:zone];
}
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;

}
void* _Nonnull
NSString_StringWithString(void* string) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString stringWithString:string];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
NSString_Alloc() {
	return [NSString alloc];
}
void* _Nonnull
NSString_ReadableTypeIdentifiersForItemProvider() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString readableTypeIdentifiersForItemProvider];
	}
	return ret;

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

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

}
BOOL
NSString_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString supportsSecureCoding];
	}
	return ret;

}
void* _Nonnull
NSString_StringWithFormat(void* format, void* object) {
	NSObject** arr = object;
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString stringWithFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
		if(ret != nil) { [ret retain]; }
	}
	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* _Nonnull
NSString_LocalizedNameOfStringEncoding(NSStringEncoding encoding) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString localizedNameOfStringEncoding:encoding];
	}
	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;

}
NSUInteger
NSString_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o hash];
	}
	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;

}
NSRange
NSString_inst_LocalizedStandardRangeOfString(void* o, void* str) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedStandardRangeOfString:str];
	}
	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_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o forwardingTargetForSelector:aSelector];
		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;

}
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* _Nonnull
NSString_inst_DecomposedStringWithCompatibilityMapping(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o decomposedStringWithCompatibilityMapping];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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_StringByAppendingPathComponent(void* o, void* str) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAppendingPathComponent:str];
		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_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];
	}
}
NSStringEncoding
NSString_inst_SmallestEncoding(void* o) {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [(NSString*)o smallestEncoding];
	}
	return ret;

}
void* _Nonnull
NSString_inst_LocalizedUppercaseString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedUppercaseString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
NSRange
NSString_inst_RangeOfComposedCharacterSequencesForRange(void* o, NSRange range) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfComposedCharacterSequencesForRange:range];
	}
	return ret;

}
BOOL
NSString_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isLike:object];
	}
	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* _Nullable
NSString_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o observationInfo];
	}
	return ret;

}
BOOL
NSString_inst_BoolValue(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o boolValue];
	}
	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;

}
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* _Nullable
NSString_inst_InitWithUTF8String(void* o, void* nullTerminatedCString) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithUTF8String:nullTerminatedCString];
	}
	return ret;

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

}
BOOL
NSString_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isNotEqualTo:object];
	}
	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_PerformSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o performSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSString_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o performSelector:aSelector withObject:object];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSString_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
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_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_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];
	}
}
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;

}
void* _Nonnull
NSString_inst_StringByDeletingPathExtension(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByDeletingPathExtension];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
void*
NSString_inst_Autorelease(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSString*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
const void* _Nullable
NSString_inst_UTF8String(void* o) {
	const char* _Nullable ret;
	@autoreleasepool {
		ret = strdup([(NSString*)o UTF8String]);
	}
	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
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_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
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* _Nonnull
NSString_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o classForCoder];
	}
	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
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];
	}
}
BOOL
NSString_inst_HasSuffix(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o hasSuffix:str];
	}
	return ret;

}
void
NSString_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSString*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
NSString_inst_LocalizedStandardContainsString(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedStandardContainsString:str];
	}
	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;

}
BOOL
NSString_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingIsLessThan:object];
	}
	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* _Nonnull
NSString_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o attributeKeys];
		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];
	}
}
unichar
NSString_inst_CharacterAtIndex(void* o, NSUInteger index) {
	unichar ret;
	@autoreleasepool {
		ret = [(NSString*)o characterAtIndex:index];
	}
	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_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;

}
BOOL
NSString_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o conformsToProtocol:aProtocol];
	}
	return ret;

}
BOOL
NSString_inst_HasPrefix(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o hasPrefix:str];
	}
	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_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingBeginsWith:object];
	}
	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* _Nonnull
NSString_inst_StringByStandardizingPath(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByStandardizingPath];
		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_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_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
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* _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;

}
BOOL
NSString_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isKindOfClass:aClass];
	}
	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;

}
BOOL
NSString_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isCaseInsensitiveLike:object];
	}
	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;

}
BOOL
NSString_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o respondsToSelector:aSelector];
	}
	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];
	}
}
NSStringEncoding
NSString_inst_FastestEncoding(void* o) {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [(NSString*)o fastestEncoding];
	}
	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;

}
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;

}
void* _Nonnull
NSString_inst_LinguisticTagsInRangeScheme(void* o, NSRange range, void* scheme, NSLinguisticTaggerOptions options, void* orthography, void** tokenRanges) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o linguisticTagsInRange:range scheme:scheme options:options orthography:orthography tokenRanges:(NSArray <NSValue*>* _Nullable* _Nullable)tokenRanges];
		if (ret != nil && ret != o) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(tokenRanges[i] == 0) { break; }
			[(id)tokenRanges[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSString_inst_LinguisticTagsInRangeSchemeOptions(void* o, NSRange range, void* scheme, NSLinguisticTaggerOptions options, void* orthography, void** tokenRanges) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o linguisticTagsInRange:range scheme:scheme options:options orthography:orthography tokenRanges:(NSArray <NSValue*>* _Nullable* _Nullable)tokenRanges];
		if (ret != nil && ret != o) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(tokenRanges[i] == 0) { break; }
			[(id)tokenRanges[i] retain];
		}
	
	}
	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;

}
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* _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_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* _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* _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_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
void
NSString_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSString*)o setNilValueForKey:key];
	}
}
void*
NSString_inst_Self(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSString*)o self];
		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;

}
long long
NSString_inst_LongLongValue(void* o) {
	long long ret;
	@autoreleasepool {
		ret = [(NSString*)o longLongValue];
	}
	return ret;

}
void
NSString_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSString*)o dealloc];
	}
}
NSUInteger
NSString_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o retainCount];
	}
	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;

}
NSUInteger
NSString_inst_Length(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o length];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByAppendingFormat(void* o, void* format, void* object) {
	NSObject** arr = object;
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAppendingFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSItemProviderRepresentationVisibility
NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(void* o, void* typeIdentifier) {
	NSItemProviderRepresentationVisibility ret;
	@autoreleasepool {
		ret = [(NSString*)o itemProviderVisibilityForRepresentationWithTypeIdentifier:typeIdentifier];
	}
	return ret;

}
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;

}
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_StringByAbbreviatingWithTildeInPath(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAbbreviatingWithTildeInPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSRange
NSString_inst_ParagraphRangeForRange(void* o, NSRange range) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o paragraphRangeForRange:range];
	}
	return ret;

}
NSComparisonResult
NSString_inst_LocalizedCompare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedCompare:string];
	}
	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;

}
NSComparisonResult
NSString_inst_CaseInsensitiveCompare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o caseInsensitiveCompare:string];
	}
	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];
	}
}
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;

}
NSRange
NSString_inst_RangeOfComposedCharacterSequenceAtIndex(void* o, NSUInteger index) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfComposedCharacterSequenceAtIndex:index];
	}
	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;

}
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_InitWithBytesNoCopyLengthEncoding(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;

}
NSUInteger
NSString_inst_LengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o lengthOfBytesUsingEncoding:enc];
	}
	return ret;

}
void
NSString_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSString*)o setObservationInfo:observationInfo];
	}
}
BOOL
NSString_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSString_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o classForKeyedArchiver];
	}
	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];
	}
}
void* _Nonnull
NSString_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
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_LocalizedCapitalizedString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedCapitalizedString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
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;

}
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_InitWithString(void* o, void* aString) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithString:aString];
	}
	return ret;

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

}
BOOL
NSString_inst_ContainsString(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o containsString:str];
	}
	return ret;

}
BOOL
NSString_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isProxy];
	}
	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;

}
BOOL
NSString_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingIsGreaterThan:object];
	}
	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;

}
BOOL
NSString_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isMemberOfClass:aClass];
	}
	return ret;

}
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;

}
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;

}
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_InitWithCharactersLength(void* o, void* characters, NSUInteger length) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithCharacters:characters length:length];
	}
	return ret;

}
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;

}
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_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*
NSString_inst_Retain(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSString*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void
NSString_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSString*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
NSString_inst_InitWithCoder(void* o, void* aDecoder) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithCoder:aDecoder];
	}
	return ret;

}
double
NSString_inst_DoubleValue(void* o) {
	double ret;
	@autoreleasepool {
		ret = [(NSString*)o doubleValue];
	}
	return ret;

}
NSRange
NSString_inst_LineRangeForRange(void* o, NSRange range) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o lineRangeForRange:range];
	}
	return ret;

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

}
void
NSString_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSString*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nullable
NSString_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o classForArchiver];
	}
	return ret;

}
BOOL
NSString_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingContains:object];
	}
	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;

}
NSInteger
NSString_inst_IntegerValue(void* o) {
	NSInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o integerValue];
	}
	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;

}
BOOL
NSString_inst_IsAbsolutePath(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isAbsolutePath];
	}
	return ret;

}
BOOL
NSString_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isEqualTo:object];
	}
	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* _Nonnull
NSString_inst_PrecomposedStringWithCanonicalMapping(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o precomposedStringWithCanonicalMapping];
		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;

}
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_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o valueForKeyPath:keyPath];
		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;

}
void* _Nonnull
NSString_inst_PrecomposedStringWithCompatibilityMapping(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o precomposedStringWithCompatibilityMapping];
		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* _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;

}
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*
NSString_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(NSString*)o zone];
	}
	return ret;

}
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*
NSString_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o copy];
	}
	return ret;

}
NSUInteger
NSString_inst_MaximumLengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o maximumLengthOfBytesUsingEncoding:enc];
	}
	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
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* _Nonnull
NSString_inst_UppercaseString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o uppercaseString];
		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
NSString_inst_Release(void* o) {
	@autoreleasepool {
		[(NSString*)o release];
	}
}
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* _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_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSString*)o setScriptingProperties:scriptingProperties];
	}
}
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*
NSString_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableCopy];
	}
	return ret;

}
float
NSString_inst_FloatValue(void* o) {
	float ret;
	@autoreleasepool {
		ret = [(NSString*)o floatValue];
	}
	return ret;

}
const void* _Nonnull
NSString_inst_FileSystemRepresentation(void* o) {
	const char* _Nonnull ret;
	@autoreleasepool {
		ret = strdup([(NSString*)o fileSystemRepresentation]);
	}
	return ret;

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

}
void*
NSString_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSString*)o debugDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isEqual:object];
	}
	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* _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_StringByRemovingPercentEncoding(void* o) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByRemovingPercentEncoding];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSString_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSString*)o class];
	}
	return ret;

}
void
NSString_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSString*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void* _Nonnull
NSString_inst_InitWithFormat(void* o, void* format, void* object) {
	NSObject** arr = object;
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithFormatLocale(void* o, void* format, void* locale, void* object) {
	NSObject** arr = object;
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithFormat:format locale:locale , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil];
	}
	return ret;

}
BOOL
NSString_inst_LocalizedCaseInsensitiveContainsString(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedCaseInsensitiveContainsString:str];
	}
	return ret;

}
BOOL
NSString_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isGreaterThan:object];
	}
	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;

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

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

}
BOOL
NSString_inst_CanBeConvertedToEncoding(void* o, NSStringEncoding encoding) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o canBeConvertedToEncoding:encoding];
	}
	return ret;

}
BOOL
NSString_inst_IsEqualToString(void* o, void* aString) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isEqualToString:aString];
	}
	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;

}
NSComparisonResult
NSString_inst_LocalizedStandardCompare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedStandardCompare:string];
	}
	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];
	}
}
FourCharCode
NSString_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSString*)o classCode];
	}
	return ret;

}
int
NSString_inst_IntValue(void* o) {
	int ret;
	@autoreleasepool {
		ret = [(NSString*)o intValue];
	}
	return ret;

}
void*
NSString_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSString*)o superclass];
	}
	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;

}
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];
	}
}
BOOL
NSString_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingEndsWith:object];
	}
	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;

}
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* _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_SubstringWithRange(void* o, NSRange range) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o substringWithRange:range];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSString*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
NSNumber_ValueWithNonretainedObject(void* anObject) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithNonretainedObject:anObject];
	}
	return ret;

}
void*
NSNumber_New() {
	NSNumber* ret;
	@autoreleasepool {
		ret = [NSNumber new];
	}
	return ret;

}
void* _Nonnull
NSNumber_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber keyPathsForValuesAffectingValueForKey:key];
	}
	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];
	}
}
void* _Nonnull
NSNumber_NumberWithFloat(float value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithFloat: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_NumberWithChar(char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithChar: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*
NSNumber_AllocWithZone(void* zone) {
	return [NSNumber allocWithZone:zone];
}
void*
NSNumber_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSNumber description];
	}
	return ret;

}
void
NSNumber_Load() {
	@autoreleasepool {
		[NSNumber load];
	}
}
void*
NSNumber_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSNumber debugDescription];
	}
	return ret;

}
void*
NSNumber_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSNumber superclass];
	}
	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_NumberWithShort(short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithShort:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithBytesObjCType(void* value, void* type) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithBytes:value objCType:type];
	}
	return ret;

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

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

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

}
NSUInteger
NSNumber_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSNumber hash];
	}
	return ret;

}
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_NumberWithUnsignedInteger(NSUInteger value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedInteger: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;

}
void* _Nonnull
NSNumber_NumberWithUnsignedChar(unsigned char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedChar:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
NSNumber_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSNumber instanceMethodSignatureForSelector:aSelector];
	}
	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_NumberWithUnsignedShort(unsigned short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedShort:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

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

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

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

}
void* _Nonnull
NSNumber_ValueWithPoint(NSPoint point) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithPoint:point];
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithObjCType(void* value, void* type) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber value:value withObjCType:type];
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithRange(NSRange range) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithRange:range];
	}
	return ret;

}
NSInteger
NSNumber_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSNumber version];
	}
	return ret;

}
void*
NSNumber_Alloc() {
	return [NSNumber alloc];
}
BOOL
NSNumber_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber resolveInstanceMethod:sel];
	}
	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_NumberWithBool(BOOL value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithBool:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

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

}
void*
NSNumber_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSNumber copyWithZone:zone];
	}
	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_ValueWithSize(NSSize size) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithSize:size];
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithEdgeInsets(NSEdgeInsets insets) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithEdgeInsets:insets];
	}
	return ret;

}
void
NSNumber_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSNumber setVersion:aVersion];
	}
}
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_ValueWithPointer(void* pointer) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithPointer:pointer];
	}
	return ret;

}
BOOL
NSNumber_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber accessInstanceVariablesDirectly];
	}
	return ret;

}
BOOL
NSNumber_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber automaticallyNotifiesObserversForKey:key];
	}
	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* _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;

}
BOOL
NSNumber_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsEqualTo:object];
	}
	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;

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

}
unsigned char
NSNumber_inst_UnsignedCharValue(void* o) {
	unsigned char ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedCharValue];
	}
	return ret;

}
NSUInteger
NSNumber_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSNumber*)o retainCount];
	}
	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;

}
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_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSNumber*)o setObservationInfo:observationInfo];
	}
}
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];
	}
}
void* _Nonnull
NSNumber_inst_InitWithInteger(void* o, NSInteger value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithInteger:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithFloat(void* o, float value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithFloat:value];
	}
	return ret;

}
NSRect
NSNumber_inst_RectValue(void* o) {
	NSRect ret;
	@autoreleasepool {
		ret = [(NSNumber*)o rectValue];
	}
	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_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o debugDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

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

}
void*
NSNumber_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o performSelector:aSelector withObject:object];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSNumber_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
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_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_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];
	}
}
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_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingBeginsWith:object];
	}
	return ret;

}
NSComparisonResult
NSNumber_inst_Compare(void* o, void* otherNumber) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSNumber*)o compare:otherNumber];
	}
	return ret;

}
BOOL
NSNumber_inst_IsEqualToNumber(void* o, void* number) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isEqualToNumber:number];
	}
	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;

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

}
void* _Nullable
NSNumber_inst_ReplacementObjectForCoder(void* o, void* aCoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o replacementObjectForCoder:aCoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	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;

}
void
NSNumber_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSNumber*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
NSNumber_inst_InitWithUnsignedChar(void* o, unsigned char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedChar:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithChar(void* o, char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithChar:value];
	}
	return ret;

}
NSUInteger
NSNumber_inst_UnsignedIntegerValue(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedIntegerValue];
	}
	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];
	}
}
void* _Nonnull
NSNumber_inst_InitWithInt(void* o, int value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithInt:value];
	}
	return ret;

}
unsigned long long
NSNumber_inst_UnsignedLongLongValue(void* o) {
	unsigned long long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedLongLongValue];
	}
	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* _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* _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_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsLessThan:object];
	}
	return ret;

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

}
void* _Nonnull
NSNumber_inst_InitWithLong(void* o, long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithLong:value];
	}
	return ret;

}
unsigned int
NSNumber_inst_UnsignedIntValue(void* o) {
	unsigned int ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedIntValue];
	}
	return ret;

}
NSPoint
NSNumber_inst_PointValue(void* o) {
	NSPoint ret;
	@autoreleasepool {
		ret = [(NSNumber*)o pointValue];
	}
	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_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSNumber*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
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;

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

}
void
NSNumber_inst_Release(void* o) {
	@autoreleasepool {
		[(NSNumber*)o release];
	}
}
void* _Nonnull
NSNumber_inst_InitWithUnsignedInt(void* o, unsigned int value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedInt:value];
	}
	return ret;

}
double
NSNumber_inst_DoubleValue(void* o) {
	double ret;
	@autoreleasepool {
		ret = [(NSNumber*)o doubleValue];
	}
	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* _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;

}
BOOL
NSNumber_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isKindOfClass:aClass];
	}
	return ret;

}
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_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSNumber*)o setNilValueForKey:key];
	}
}
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*
NSNumber_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSNumber_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o doesContain:object];
	}
	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;

}
void
NSNumber_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSNumber*)o setScriptingProperties:scriptingProperties];
	}
}
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;

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

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

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedInteger(void* o, NSUInteger value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedInteger:value];
	}
	return ret;

}
const void* _Nonnull
NSNumber_inst_ObjCType(void* o) {
	const char* _Nonnull ret;
	@autoreleasepool {
		ret = strdup([(NSNumber*)o objCType]);
	}
	return ret;

}
BOOL
NSNumber_inst_IsEqualToValue(void* o, void* value) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isEqualToValue:value];
	}
	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;

}
int
NSNumber_inst_IntValue(void* o) {
	int ret;
	@autoreleasepool {
		ret = [(NSNumber*)o intValue];
	}
	return ret;

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

}
BOOL
NSNumber_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isProxy];
	}
	return ret;

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

}
BOOL
NSNumber_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isMemberOfClass:aClass];
	}
	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* _Nullable
NSNumber_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o awakeAfterUsingCoder:aDecoder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSNumber_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o conformsToProtocol:aProtocol];
	}
	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_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedShort(void* o, unsigned short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedShort:value];
	}
	return ret;

}
unsigned short
NSNumber_inst_UnsignedShortValue(void* o) {
	unsigned short ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedShortValue];
	}
	return ret;

}
void*
NSNumber_inst_Autorelease(void* o) {
	NSNumber* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSNumber_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSNumber*)o superclass];
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingContains: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_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isEqual:object];
	}
	return ret;

}
float
NSNumber_inst_FloatValue(void* o) {
	float ret;
	@autoreleasepool {
		ret = [(NSNumber*)o floatValue];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_InitWithCoder(void* o, void* aDecoder) {
	NSNumber* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithCoder:aDecoder];
	}
	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;

}
NSSize
NSNumber_inst_SizeValue(void* o) {
	NSSize ret;
	@autoreleasepool {
		ret = [(NSNumber*)o sizeValue];
	}
	return ret;

}
BOOL
NSNumber_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isLike:object];
	}
	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;

}
short
NSNumber_inst_ShortValue(void* o) {
	short ret;
	@autoreleasepool {
		ret = [(NSNumber*)o shortValue];
	}
	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* _Nullable
NSNumber_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classForArchiver];
	}
	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_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*
NSNumber_inst_Self(void* o) {
	NSNumber* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o self];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
long long
NSNumber_inst_LongLongValue(void* o) {
	long long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o longLongValue];
	}
	return ret;

}
NSInteger
NSNumber_inst_IntegerValue(void* o) {
	NSInteger ret;
	@autoreleasepool {
		ret = [(NSNumber*)o integerValue];
	}
	return ret;

}
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];
	}
}
void* _Nonnull
NSNumber_inst_InitWithLongLong(void* o, long long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithLongLong:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedLong(void* o, unsigned long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedLong:value];
	}
	return ret;

}
NSEdgeInsets
NSNumber_inst_EdgeInsetsValue(void* o) {
	NSEdgeInsets ret;
	@autoreleasepool {
		ret = [(NSNumber*)o edgeInsetsValue];
	}
	return ret;

}
void
NSNumber_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSNumber*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
unsigned long
NSNumber_inst_UnsignedLongValue(void* o) {
	unsigned long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedLongValue];
	}
	return ret;

}
long
NSNumber_inst_LongValue(void* o) {
	long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o longValue];
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsLessThanOrEqualTo:object];
	}
	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
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];
	}
}
void* _Nonnull
NSNumber_inst_InitWithShort(void* o, short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithShort:value];
	}
	return ret;

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

}
void* _Nullable
NSNumber_inst_ObservationInfo(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o observationInfo];
	}
	return ret;

}
void
NSNumber_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSNumber*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
NSNumber_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o zone];
	}
	return ret;

}
char
NSNumber_inst_CharValue(void* o) {
	char ret;
	@autoreleasepool {
		ret = [(NSNumber*)o charValue];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_PointerValue(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o pointerValue];
	}
	return ret;

}
NSUInteger
NSNumber_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSNumber*)o hash];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithBool(void* o, BOOL value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithBool:value];
	}
	return ret;

}
void
NSNumber_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSNumber*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void*
NSNumber_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableCopy];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classForKeyedArchiver];
	}
	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;

}
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* _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*
NSNumber_inst_Retain(void* o) {
	NSNumber* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSNumber_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSNumber*)o class];
	}
	return ret;

}
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* _Nonnull
NSNumber_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classForCoder];
	}
	return ret;

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

}
BOOL
NSNumber_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isGreaterThanOrEqualTo:object];
	}
	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_InitWithUnsignedLongLong(void* o, unsigned long long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedLongLong:value];
	}
	return ret;

}
BOOL
NSNumber_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isEqualTo:object];
	}
	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
NSNumber_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSNumber*)o dealloc];
	}
}
BOOL
NSNumber_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isLessThan:object];
	}
	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];
	}
}
NSRange
NSNumber_inst_RangeValue(void* o) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSNumber*)o rangeValue];
	}
	return ret;

}
void
NSNumber_inst_GetValue(void* o, void* value) {
	@autoreleasepool {
		[(NSNumber*)o getValue:value];
	}
}
void
NSNumber_inst_GetValueSize(void* o, void* value, NSUInteger size) {
	@autoreleasepool {
		[(NSNumber*)o getValue:value size:size];
	}
}
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
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];
	}
}
BOOL
NSNumber_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingEndsWith:object];
	}
	return ret;

}
BOOL
NSNumber_inst_BoolValue(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o boolValue];
	}
	return ret;

}
BOOL
NSNumber_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o respondsToSelector:aSelector];
	}
	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_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isLessThanOrEqualTo:object];
	}
	return ret;

}

void CBDelegateCentralManagerDidUpdateState(void*, void*);
void CBDelegateCentralManagerDidConnectPeripheral(void*, void*, void*);
void CBDelegateCentralManagerDidDisconnectPeripheral(void*, void*, void*, void*);
void CBDelegateCentralManagerDidDiscoverPeripheral(void*, void*, void*, 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)centralManagerDidUpdateState:(CBCentralManager* _Nonnull)central;
- (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)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)centralManagerDidUpdateState:(CBCentralManager* _Nonnull)central
{
	CBDelegateCentralManagerDidUpdateState(self, central);
}


- (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)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() {
	[[NSThread new] start]; // put the runtime into multi-threaded mode
}

*/
import "C"

import (
	"unsafe"
	"runtime"
	"sync"
)

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 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 _NSZone = C.struct__NSZone

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 Class *C.struct_objc_class

type BOOL C.uchar

type SEL *C.struct_objc_selector

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 NSUInteger C.ulong

type NSInteger C.long

type Protocol interface {
	Ptr() unsafe.Pointer
}

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 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 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 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 CBPeripheralState C.enum_CBPeripheralState

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 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 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 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 CBCharacteristicWriteType C.enum_CBCharacteristicWriteType

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 FourCharCode C.UInt32

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 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 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 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 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 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 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 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 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 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 NSKeyValueSetMutationKind C.enum_NSKeyValueSetMutationKind

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 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 CBCharacteristicProperties C.enum_CBCharacteristicProperties

type NSZone = C.struct__NSZone

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 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 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 CBPeripheralManagerAuthorizationStatus C.enum_CBPeripheralManagerAuthorizationStatus

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 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 Dispatch_queue_t = *Id

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 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 CBManagerState C.enum_CBManagerState

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 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 NSRange = C.struct__NSRange

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 NSFastEnumerationState = C.struct_NSFastEnumerationState

type UnsignedChar C.uchar

type OSType C.FourCharCode

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 UnsignedLongLong C.ulonglong

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 NSDataReadingOptions C.enum_NSDataReadingOptions

type NSDataBase64DecodingOptions C.enum_NSDataBase64DecodingOptions

type NSDataWritingOptions C.enum_NSDataWritingOptions

type NSDataBase64EncodingOptions C.enum_NSDataBase64EncodingOptions

type NSDataSearchOptions C.enum_NSDataSearchOptions

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 Char C.char

type NSStringEncoding C.NSUInteger

type NSItemProviderRepresentationVisibility C.enum_NSItemProviderRepresentationVisibility

type Unichar C.ushort

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 NSStringCompareOptions C.enum_NSStringCompareOptions

type NSLinguisticTagScheme = *NSString

type NSLinguisticTaggerOptions C.enum_NSLinguisticTaggerOptions

type NSOrthography struct { Id }
func (o *NSOrthography) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSOrthography() *NSOrthography {
	return (*NSOrthography)(unsafe.Pointer(o))
}

type NSStringTransform = *NSString

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 LongLong C.longlong

type NSStringEncodingConversionOptions C.enum_NSStringEncodingConversionOptions

type NSRangePointer *C.NSRange

type NSComparisonResult C.enum_NSComparisonResult

type Double C.double

type Float C.float

type Int C.int

type NSRect C.CGRect

type Short C.short

type UnsignedInt C.uint

type UnsignedLong C.ulong

type UnsignedShort C.ushort

type NSPoint C.CGPoint

type Long C.long

type NSSize C.CGSize

type NSEdgeInsets = C.struct_NSEdgeInsets

type NSDecimal = C.struct_NSDecimal

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 CBAttributePermissionsReadable NSUInteger= C.CBAttributePermissionsReadable
const CBAttributePermissionsWriteable NSUInteger= C.CBAttributePermissionsWriteable
const CBAttributePermissionsReadEncryptionRequired NSUInteger= C.CBAttributePermissionsReadEncryptionRequired
const CBAttributePermissionsWriteEncryptionRequired NSUInteger= C.CBAttributePermissionsWriteEncryptionRequired

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 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 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 CBPeripheralManagerAuthorizationStatusNotDetermined NSInteger= C.CBPeripheralManagerAuthorizationStatusNotDetermined
const CBPeripheralManagerAuthorizationStatusRestricted NSInteger= C.CBPeripheralManagerAuthorizationStatusRestricted
const CBPeripheralManagerAuthorizationStatusDenied NSInteger= C.CBPeripheralManagerAuthorizationStatusDenied
const CBPeripheralManagerAuthorizationStatusAuthorized NSInteger= C.CBPeripheralManagerAuthorizationStatusAuthorized

const CBPeripheralStateDisconnected NSInteger= C.CBPeripheralStateDisconnected
const CBPeripheralStateConnecting NSInteger= C.CBPeripheralStateConnecting
const CBPeripheralStateConnected NSInteger= C.CBPeripheralStateConnected
const CBPeripheralStateDisconnecting NSInteger= C.CBPeripheralStateDisconnecting

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 CBPeripheralManagerConnectionLatencyLow NSInteger= C.CBPeripheralManagerConnectionLatencyLow
const CBPeripheralManagerConnectionLatencyMedium NSInteger= C.CBPeripheralManagerConnectionLatencyMedium
const CBPeripheralManagerConnectionLatencyHigh NSInteger= C.CBPeripheralManagerConnectionLatencyHigh


func Selector(s string) SEL {
	return (SEL)(unsafe.Pointer(C.selectorFromString(C.CString(s))))
}

func Autoreleasepool(f func()) {
	pool := NSAutoreleasePoolAlloc().Init()
	f()
	pool.Drain()
}

func (e *NSEnumerator) ForIn(f func(*Id) bool) {
	for o := e.NextObject(); o.Ptr() != nil; o = e.NextObject() {
		if !f(o) { break }
	}
}

func (o *NSString) String() string {
	utf8 := o.UTF8String()
	ret := utf8.String()
	utf8.Free()
	runtime.KeepAlive(o)
	return ret
}

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 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 CBPeripheralDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_ClassForKeyedUnarchiver()))
	return ret
}

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 CBPeripheralAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBPeripheral_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	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 := (C.CBPeripheral_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBPeripheralInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBPeripheral_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	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 CBPeripheralHash() NSUInteger {
	ret := (NSUInteger)(C.CBPeripheral_Hash())
	return ret
}

func CBPeripheralDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralSetVersion(aVersion NSInteger)  {
	C.CBPeripheral_SetVersion((C.NSInteger)(aVersion))
}

func CBPeripheralSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_Superclass()))
	return ret
}

func CBPeripheralIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBPeripheral_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func CBPeripheralClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_Class()))
	return ret
}

func CBPeripheralConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBPeripheral_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

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 CBPeripheralAccessInstanceVariablesDirectly() bool {
	ret := (C.CBPeripheral_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBPeripheralLoad()  {
	C.CBPeripheral_Load()
}

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 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 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 CBPeripheralClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBPeripheral_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBPeripheralVersion() NSInteger {
	ret := (NSInteger)(C.CBPeripheral_Version())
	return ret
}

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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBPeripheral_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) State() CBPeripheralState {
	ret := (CBPeripheralState)(C.CBPeripheral_inst_State(o.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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBPeripheral_inst_ClassCode(o.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 (o *CBPeripheral) ReadRSSI()  {
	C.CBPeripheral_inst_ReadRSSI(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBPeripheral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) DiscoverCharacteristics(characteristicUUIDs *NSArray, service *CBService)  {
	C.CBPeripheral_inst_DiscoverCharacteristics(o.Ptr(), characteristicUUIDs.Ptr(), service.Ptr())
	runtime.KeepAlive(o)
}

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) 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) IsLessThan(object NSObject) bool {
	ret := (C.CBPeripheral_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ScriptingContains(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) 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) CanSendWriteWithoutResponse() bool {
	ret := (C.CBPeripheral_inst_CanSendWriteWithoutResponse(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBPeripheral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBPeripheral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) IsEqualTo(object NSObject) bool {
	ret := (C.CBPeripheral_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBPeripheral_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) IsGreaterThan(object NSObject) bool {
	ret := (C.CBPeripheral_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) SetNilValueForKey(key *NSString)  {
	C.CBPeripheral_inst_SetNilValueForKey(o.Ptr(), 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheral_inst_ObservationInfo(o.Ptr())))
	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) SetDelegate(delegate NSObject)  {
	C.CBPeripheral_inst_SetDelegate(o.Ptr(), delegate.Ptr())
	runtime.KeepAlive(o)
}

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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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 := (C.CBPeripheral_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBPeripheral_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBPeripheral_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBPeripheral_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForCoder(o.Ptr())))
	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) 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) 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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBPeripheral_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) IsLike(object *NSString) bool {
	ret := (C.CBPeripheral_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) DiscoverServices(serviceUUIDs *NSArray)  {
	C.CBPeripheral_inst_DiscoverServices(o.Ptr(), serviceUUIDs.Ptr())
	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) Dealloc()  {
	C.CBPeripheral_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ReadValueForDescriptor(descriptor *CBDescriptor)  {
	C.CBPeripheral_inst_ReadValueForDescriptor(o.Ptr(), descriptor.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(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) ReadValueForCharacteristic(characteristic *CBCharacteristic)  {
	C.CBPeripheral_inst_ReadValueForCharacteristic(o.Ptr(), characteristic.Ptr())
	runtime.KeepAlive(o)
}

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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBPeripheral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.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) 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) 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 := (C.CBPeripheral_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) 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 CBServiceClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_ClassForKeyedUnarchiver()))
	return ret
}

func CBServiceAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBService_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func CBServiceConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBService_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func CBServiceHash() NSUInteger {
	ret := (NSUInteger)(C.CBService_Hash())
	return ret
}

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 CBServiceLoad()  {
	C.CBService_Load()
}

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 CBServiceResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBService_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBServiceResolveClassMethod(sel SEL) bool {
	ret := (C.CBService_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBServiceDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBService_Description())
	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 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 CBServiceClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBServiceIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBService_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	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 CBServiceSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_Superclass()))
	return ret
}

func CBServiceInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBService_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	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 CBServiceDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBService_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBServiceSetVersion(aVersion NSInteger)  {
	C.CBService_SetVersion((C.NSInteger)(aVersion))
}

func CBServiceVersion() NSInteger {
	ret := (NSInteger)(C.CBService_Version())
	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 CBServiceAccessInstanceVariablesDirectly() bool {
	ret := (C.CBService_AccessInstanceVariablesDirectly()) != 0
	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 (o *CBService) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForCoder(o.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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBService_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBService_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBService_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBService_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBService_inst_ClassCode(o.Ptr()))
	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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBService_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) 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) 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 := (C.CBService_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBService_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBService_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBService_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) IsGreaterThan(object NSObject) bool {
	ret := (C.CBService_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBService_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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) 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) 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) 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) 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) 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) 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) IsEqualTo(object NSObject) bool {
	ret := (C.CBService_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsLike(object *NSString) bool {
	ret := (C.CBService_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForKeyedArchiver(o.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) 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) 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) 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) SetNilValueForKey(key *NSString)  {
	C.CBService_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) IsPrimary() bool {
	ret := (C.CBService_inst_IsPrimary(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) Dealloc()  {
	C.CBService_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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 (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) 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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) ScriptingContains(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) IsLessThan(object NSObject) bool {
	ret := (C.CBService_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBService_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBService_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBService_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) DoesContain(object NSObject) bool {
	ret := (C.CBService_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBService_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBService_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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 CBCharacteristicHash() NSUInteger {
	ret := (NSUInteger)(C.CBCharacteristic_Hash())
	return ret
}

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 CBCharacteristicAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBCharacteristic_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func CBCharacteristicResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBCharacteristic_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBCharacteristicSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Superclass()))
	return ret
}

func CBCharacteristicDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicAccessInstanceVariablesDirectly() bool {
	ret := (C.CBCharacteristic_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBCharacteristicClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_ClassForKeyedUnarchiver()))
	return ret
}

func CBCharacteristicConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBCharacteristic_ConformsToProtocol(protocol.Ptr())) != 0
	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 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 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 CBCharacteristicKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicResolveClassMethod(sel SEL) bool {
	ret := (C.CBCharacteristic_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

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 CBCharacteristicIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBCharacteristic_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func CBCharacteristicClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Class()))
	return ret
}

func CBCharacteristicLoad()  {
	C.CBCharacteristic_Load()
}

func CBCharacteristicSetVersion(aVersion NSInteger)  {
	C.CBCharacteristic_SetVersion((C.NSInteger)(aVersion))
}

func CBCharacteristicClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	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 CBCharacteristicInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBCharacteristic_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	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 CBCharacteristicDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicVersion() NSInteger {
	ret := (NSInteger)(C.CBCharacteristic_Version())
	return ret
}

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) 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) 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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) DoesContain(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBCharacteristic_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) SetNilValueForKey(key *NSString)  {
	C.CBCharacteristic_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) Properties() CBCharacteristicProperties {
	ret := (CBCharacteristicProperties)(C.CBCharacteristic_inst_Properties(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBCharacteristic_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) IsLessThan(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForArchiver(o.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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) 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) 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) 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) 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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBCharacteristic_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) 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) IsEqualTo(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingContains(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) IsNotifying() bool {
	ret := (C.CBCharacteristic_inst_IsNotifying(o.Ptr())) != 0
	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) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) Dealloc()  {
	C.CBCharacteristic_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForCoder(o.Ptr())))
	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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBCharacteristic_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) IsGreaterThan(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBCharacteristic_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBCharacteristic_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) IsLike(object *NSString) bool {
	ret := (C.CBCharacteristic_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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 := (C.CBCharacteristic_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCharacteristic_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCharacteristic_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCharacteristic_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) 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) 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) 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) 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) 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) 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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBCharacteristic_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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 CBDescriptorInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBDescriptor_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func CBDescriptorConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBDescriptor_ConformsToProtocol(protocol.Ptr())) != 0
	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 CBDescriptorClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_ClassForKeyedUnarchiver()))
	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 CBDescriptorClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_Class()))
	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 CBDescriptorResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBDescriptor_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	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 CBDescriptorAccessInstanceVariablesDirectly() bool {
	ret := (C.CBDescriptor_AccessInstanceVariablesDirectly()) != 0
	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 CBDescriptorVersion() NSInteger {
	ret := (NSInteger)(C.CBDescriptor_Version())
	return ret
}

func CBDescriptorIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBDescriptor_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func CBDescriptorLoad()  {
	C.CBDescriptor_Load()
}

func CBDescriptorDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBDescriptorSetVersion(aVersion NSInteger)  {
	C.CBDescriptor_SetVersion((C.NSInteger)(aVersion))
}

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 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 CBDescriptorSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_Superclass()))
	return ret
}

func CBDescriptorDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBDescriptorHash() NSUInteger {
	ret := (NSUInteger)(C.CBDescriptor_Hash())
	return ret
}

func CBDescriptorClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	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 CBDescriptorResolveClassMethod(sel SEL) bool {
	ret := (C.CBDescriptor_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBDescriptorAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBDescriptor_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func (o *CBDescriptor) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBDescriptor_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBDescriptor_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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 := (C.CBDescriptor_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBDescriptor_inst_ClassCode(o.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) 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) 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) 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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBDescriptor_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBDescriptor_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForCoder(o.Ptr())))
	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) 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) 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 (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) 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) 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) ScriptingContains(object NSObject) bool {
	ret := (C.CBDescriptor_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBDescriptor_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) DoesContain(object NSObject) bool {
	ret := (C.CBDescriptor_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBDescriptor_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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, array *NSArray)  {
	C.CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	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) 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) SetNilValueForKey(key *NSString)  {
	C.CBDescriptor_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBDescriptor_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	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 := (C.CBDescriptor_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBDescriptor_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBDescriptor_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBDescriptor_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBDescriptor_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) Dealloc()  {
	C.CBDescriptor_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) IsGreaterThan(object NSObject) bool {
	ret := (C.CBDescriptor_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) IsLessThan(object NSObject) bool {
	ret := (C.CBDescriptor_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBDescriptor_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBDescriptor_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBDescriptor_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsEqualTo(object NSObject) bool {
	ret := (C.CBDescriptor_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBDescriptor_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBDescriptor_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

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) IsLike(object *NSString) bool {
	ret := (C.CBDescriptor_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBDescriptor_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBDescriptor_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

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) 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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBDescriptor_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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 CBUUIDInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func CBUUIDHash() NSUInteger {
	ret := (NSUInteger)(C.CBUUID_Hash())
	return ret
}

func CBUUIDClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_Class()))
	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 CBUUIDClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBUUIDResolveClassMethod(sel SEL) bool {
	ret := (C.CBUUID_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	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 CBUUIDVersion() NSInteger {
	ret := (NSInteger)(C.CBUUID_Version())
	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 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 := (C.CBUUID_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBUUIDClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_ClassForKeyedUnarchiver()))
	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 CBUUIDSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_Superclass()))
	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 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 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 CBUUIDAccessInstanceVariablesDirectly() bool {
	ret := (C.CBUUID_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBUUIDLoad()  {
	C.CBUUID_Load()
}

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 CBUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBUUID_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func CBUUIDIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBUUID_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	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 CBUUIDConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBUUID_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

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 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 CBUUIDSetVersion(aVersion NSInteger)  {
	C.CBUUID_SetVersion((C.NSInteger)(aVersion))
}

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 (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 := (C.CBUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) 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) 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) 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) 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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) 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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) DoesContain(object NSObject) bool {
	ret := (C.CBUUID_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) 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) 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) 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) 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) 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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBUUID_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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) 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) Dealloc()  {
	C.CBUUID_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsEqualTo(object NSObject) bool {
	ret := (C.CBUUID_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) IsLike(object *NSString) bool {
	ret := (C.CBUUID_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBUUID_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.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) IsGreaterThan(object NSObject) bool {
	ret := (C.CBUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBUUID) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBUUID_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) SetNilValueForKey(key *NSString)  {
	C.CBUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) IsLessThan(object NSObject) bool {
	ret := (C.CBUUID_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingContains(object NSObject) bool {
	ret := (C.CBUUID_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func NSAutoreleasePoolDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSAutoreleasePoolSetVersion(aVersion NSInteger)  {
	C.NSAutoreleasePool_SetVersion((C.NSInteger)(aVersion))
}

func NSAutoreleasePoolVersion() NSInteger {
	ret := (NSInteger)(C.NSAutoreleasePool_Version())
	return ret
}

func NSAutoreleasePoolAddObject(anObject NSObject)  {
	C.NSAutoreleasePool_AddObject(anObject.Ptr())
}

func NSAutoreleasePoolResolveClassMethod(sel SEL) bool {
	ret := (C.NSAutoreleasePool_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSAutoreleasePoolDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSAutoreleasePoolInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSAutoreleasePool_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	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 NSAutoreleasePoolClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Class()))
	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 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 NSAutoreleasePoolClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

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 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 NSAutoreleasePoolResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSAutoreleasePool_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSAutoreleasePoolAccessInstanceVariablesDirectly() bool {
	ret := (C.NSAutoreleasePool_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func NSAutoreleasePoolClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_ClassForKeyedUnarchiver()))
	return ret
}

func NSAutoreleasePoolConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSAutoreleasePool_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

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 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 NSAutoreleasePoolHash() NSUInteger {
	ret := (NSUInteger)(C.NSAutoreleasePool_Hash())
	return ret
}

func NSAutoreleasePoolSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Superclass()))
	return ret
}

func NSAutoreleasePoolLoad()  {
	C.NSAutoreleasePool_Load()
}

func NSAutoreleasePoolAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSAutoreleasePool_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func NSAutoreleasePoolIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSAutoreleasePool_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) Dealloc()  {
	C.NSAutoreleasePool_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ScriptingContains(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForKeyedArchiver(o.Ptr())))
	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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSAutoreleasePool_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) IsEqualTo(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) SetNilValueForKey(key *NSString)  {
	C.NSAutoreleasePool_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSAutoreleasePool_inst_ObservationInfo(o.Ptr())))
	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) 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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForCoder(o.Ptr())))
	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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSAutoreleasePool_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSAutoreleasePool_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) 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 := (C.NSAutoreleasePool_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSAutoreleasePool_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSAutoreleasePool_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSAutoreleasePool_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForArchiver(o.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) 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) 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) IsLike(object *NSString) bool {
	ret := (C.NSAutoreleasePool_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSAutoreleasePool_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) IsLessThan(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSAutoreleasePool_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) IsGreaterThan(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) DoesContain(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) AddObject(anObject NSObject)  {
	C.NSAutoreleasePool_inst_AddObject(o.Ptr(), anObject.Ptr())
	runtime.KeepAlive(o)
}

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) Drain()  {
	C.NSAutoreleasePool_inst_Drain(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSAutoreleasePool_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSAutoreleasePool_inst_ForwardInvocation(o.Ptr(), anInvocation.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) 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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSAutoreleasePool_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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 CBPeripheralManagerResolveClassMethod(sel SEL) bool {
	ret := (C.CBPeripheralManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	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 CBPeripheralManagerVersion() NSInteger {
	ret := (NSInteger)(C.CBPeripheralManager_Version())
	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 CBPeripheralManagerResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBPeripheralManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	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 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 CBPeripheralManagerClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Class()))
	return ret
}

func CBPeripheralManagerLoad()  {
	C.CBPeripheralManager_Load()
}

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 CBPeripheralManagerAccessInstanceVariablesDirectly() bool {
	ret := (C.CBPeripheralManager_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBPeripheralManagerInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBPeripheralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func CBPeripheralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBPeripheralManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func CBPeripheralManagerIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBPeripheralManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func GetCBPeripheralManagerAuthorizationStatus() CBPeripheralManagerAuthorizationStatus {
	ret := (CBPeripheralManagerAuthorizationStatus)(C.CBPeripheralManager_AuthorizationStatus())
	return ret
}

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 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 CBPeripheralManagerConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBPeripheralManager_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func CBPeripheralManagerHash() NSUInteger {
	ret := (NSUInteger)(C.CBPeripheralManager_Hash())
	return ret
}

func CBPeripheralManagerDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralManagerClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_ClassForKeyedUnarchiver()))
	return ret
}

func CBPeripheralManagerSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Superclass()))
	return ret
}

func CBPeripheralManagerDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralManagerSetVersion(aVersion NSInteger)  {
	C.CBPeripheralManager_SetVersion((C.NSInteger)(aVersion))
}

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 CBPeripheralManagerClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBPeripheralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingContains(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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, array *NSArray)  {
	C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	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) 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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBPeripheralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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 := (C.CBPeripheralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBPeripheralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBPeripheralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBPeripheralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) 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 (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) 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) UpdateValue(value *NSData, characteristic *CBMutableCharacteristic, centrals *NSArray) bool {
	ret := (C.CBPeripheralManager_inst_UpdateValue(o.Ptr(), value.Ptr(), characteristic.Ptr(), centrals.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBPeripheralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) SetDelegate(delegate NSObject)  {
	C.CBPeripheralManager_inst_SetDelegate(o.Ptr(), delegate.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) 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) 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) 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) SetNilValueForKey(key *NSString)  {
	C.CBPeripheralManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) AddService(service *CBMutableService)  {
	C.CBPeripheralManager_inst_AddService(o.Ptr(), service.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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 := (C.CBPeripheralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBPeripheralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) StartAdvertising(advertisementData *NSDictionary)  {
	C.CBPeripheralManager_inst_StartAdvertising(o.Ptr(), advertisementData.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBPeripheralManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) DoesContain(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) 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) IsAdvertising() bool {
	ret := (C.CBPeripheralManager_inst_IsAdvertising(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) RemoveService(service *CBMutableService)  {
	C.CBPeripheralManager_inst_RemoveService(o.Ptr(), service.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) RemoveAllServices()  {
	C.CBPeripheralManager_inst_RemoveAllServices(o.Ptr())
	runtime.KeepAlive(o)
}

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) 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) Dealloc()  {
	C.CBPeripheralManager_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) RespondToRequest(request *CBATTRequest, result CBATTError)  {
	C.CBPeripheralManager_inst_RespondToRequest(o.Ptr(), request.Ptr(), (C.CBATTError)(result))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) IsGreaterThan(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBPeripheralManager_inst_ClassCode(o.Ptr()))
	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) IsLike(object *NSString) bool {
	ret := (C.CBPeripheralManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBPeripheralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) State() CBManagerState {
	ret := (CBManagerState)(C.CBPeripheralManager_inst_State(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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBPeripheralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsLessThan(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) StopAdvertising()  {
	C.CBPeripheralManager_inst_StopAdvertising(o.Ptr())
	runtime.KeepAlive(o)
}

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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsEqualTo(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheralManager_inst_ObservationInfo(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) 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) 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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBPeripheralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	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 NSArrayIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSArray_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	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 NSArraySuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_Superclass()))
	return ret
}

func NSArrayResolveClassMethod(sel SEL) bool {
	ret := (C.NSArray_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSArrayDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayLoad()  {
	C.NSArray_Load()
}

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 NSArrayClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_ClassForKeyedUnarchiver()))
	return ret
}

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 NSArraySetVersion(aVersion NSInteger)  {
	C.NSArray_SetVersion((C.NSInteger)(aVersion))
}

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 NSArrayWithObjects(firstObj NSObject, objects ...NSObject) *NSArray {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObjects(firstObj.Ptr(), unsafe.Pointer(&object)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayWithContentsOfFile(path *NSString) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfFile(path.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	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 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 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 NSArrayResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSArray_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	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 NSArrayHash() NSUInteger {
	ret := (NSUInteger)(C.NSArray_Hash())
	return ret
}

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 NSArrayConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSArray_ConformsToProtocol(protocol.Ptr())) != 0
	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 NSArrayVersion() NSInteger {
	ret := (NSInteger)(C.NSArray_Version())
	return ret
}

func NSArraySupportsSecureCoding() bool {
	ret := (C.NSArray_SupportsSecureCoding()) != 0
	return ret
}

func NSArrayClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSArray_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	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 NSArrayWithContentsOfURL(url *NSURL) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfURL(url.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	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 NSArrayInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSArray_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func NSArrayClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_Class()))
	return ret
}

func NSArrayDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayAccessInstanceVariablesDirectly() bool {
	ret := (C.NSArray_AccessInstanceVariablesDirectly()) != 0
	return ret
}

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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSArray_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) 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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingContains(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) 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) 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) 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) Dealloc()  {
	C.NSArray_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsEqualToArray(otherArray *NSArray) bool {
	ret := (C.NSArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsLike(object *NSString) bool {
	ret := (C.NSArray_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) DoesContain(object NSObject) bool {
	ret := (C.NSArray_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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 (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 := (C.NSArray_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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 := (C.NSArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 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) WriteToURLAtomically(url *NSURL, atomically BOOL) bool {
	ret := (C.NSArray_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) InitWithCoder(aDecoder *NSCoder) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithCoder(o.Ptr(), aDecoder.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) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool {
	ret := (C.NSArray_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0
	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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) InitWithObjects(firstObj NSObject, objects ...NSObject) *NSArray {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr(), unsafe.Pointer(&object)))
	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) 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) 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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSArray_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) InitWithContentsOfFile(path *NSString) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfFile(o.Ptr(), path.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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSArray_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForArchiver(o.Ptr())))
	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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSArray_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSArray) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) IsEqualTo(object NSObject) bool {
	ret := (C.NSArray_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSArray_inst_ObservationInfo(o.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) 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) Count() NSUInteger {
	ret := (NSUInteger)(C.NSArray_inst_Count(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) InitWithContentsOfURL(url *NSURL) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfURL(o.Ptr(), url.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) 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) 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) 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) 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) 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) IsLessThan(object NSObject) bool {
	ret := (C.NSArray_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) ContainsObject(anObject NSObject) bool {
	ret := (C.NSArray_inst_ContainsObject(o.Ptr(), anObject.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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 := (C.NSArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) 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) 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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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 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 NSMutableArraySuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_Superclass()))
	return ret
}

func NSMutableArrayDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayLoad()  {
	C.NSMutableArray_Load()
}

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 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 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 NSMutableArraySetVersion(aVersion NSInteger)  {
	C.NSMutableArray_SetVersion((C.NSInteger)(aVersion))
}

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 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 NSMutableArrayKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	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 NSMutableArrayHash() NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_Hash())
	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 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 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 NSMutableArrayWithObjects(firstObj NSObject, objects ...NSObject) *NSMutableArray {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObjects(firstObj.Ptr(), unsafe.Pointer(&object)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSMutableArray_ConformsToProtocol(protocol.Ptr())) != 0
	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 NSMutableArrayInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSMutableArray_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func NSMutableArrayAccessInstanceVariablesDirectly() bool {
	ret := (C.NSMutableArray_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func NSMutableArraySupportsSecureCoding() bool {
	ret := (C.NSMutableArray_SupportsSecureCoding()) != 0
	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 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 NSMutableArrayIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSMutableArray_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func NSMutableArrayClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_ClassForKeyedUnarchiver()))
	return ret
}

func NSMutableArrayResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSMutableArray_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	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 NSMutableArrayVersion() NSInteger {
	ret := (NSInteger)(C.NSMutableArray_Version())
	return ret
}

func NSMutableArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSMutableArray_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func NSMutableArrayDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayResolveClassMethod(sel SEL) bool {
	ret := (C.NSMutableArray_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSMutableArrayClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_Class()))
	return ret
}

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) SetNilValueForKey(key *NSString)  {
	C.NSMutableArray_inst_SetNilValueForKey(o.Ptr(), key.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) 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) 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) 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) 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 := (C.NSMutableArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSMutableArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSMutableArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSMutableArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) SetObjectAtIndexedSubscript(obj NSObject, idx NSUInteger)  {
	C.NSMutableArray_inst_SetObjectAtIndexedSubscript(o.Ptr(), obj.Ptr(), (C.NSUInteger)(idx))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSMutableArray_inst_ClassCode(o.Ptr()))
	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) IsLike(object *NSString) bool {
	ret := (C.NSMutableArray_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool {
	ret := (C.NSMutableArray_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0
	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) 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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) SortUsingDescriptors(sortDescriptors *NSArray)  {
	C.NSMutableArray_inst_SortUsingDescriptors(o.Ptr(), sortDescriptors.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) Dealloc()  {
	C.NSMutableArray_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) IsEqualTo(object NSObject) bool {
	ret := (C.NSMutableArray_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) RemoveLastObject()  {
	C.NSMutableArray_inst_RemoveLastObject(o.Ptr())
	runtime.KeepAlive(o)
}

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 := (C.NSMutableArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 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) WriteToURLAtomically(url *NSURL, atomically BOOL) bool {
	ret := (C.NSMutableArray_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) 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) 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) Count() NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_inst_Count(o.Ptr()))
	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) 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) 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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) InsertObjectsAtIndexes(objects *NSArray, indexes *NSIndexSet)  {
	C.NSMutableArray_inst_InsertObjectsAtIndexes(o.Ptr(), objects.Ptr(), indexes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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 (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) DoesContain(object NSObject) bool {
	ret := (C.NSMutableArray_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) ExchangeObjectAtIndexWithObjectAtIndex(idx1 NSUInteger, idx2 NSUInteger)  {
	C.NSMutableArray_inst_ExchangeObjectAtIndexWithObjectAtIndex(o.Ptr(), (C.NSUInteger)(idx1), (C.NSUInteger)(idx2))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SetArray(otherArray *NSArray)  {
	C.NSMutableArray_inst_SetArray(o.Ptr(), otherArray.Ptr())
	runtime.KeepAlive(o)
}

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) RemoveObjectsAtIndexes(indexes *NSIndexSet)  {
	C.NSMutableArray_inst_RemoveObjectsAtIndexes(o.Ptr(), indexes.Ptr())
	runtime.KeepAlive(o)
}

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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSMutableArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) SortUsingSelector(comparator SEL)  {
	C.NSMutableArray_inst_SortUsingSelector(o.Ptr(), unsafe.Pointer(comparator))
	runtime.KeepAlive(o)
}

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) 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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithCoder(aDecoder *NSCoder) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithCoder(o.Ptr(), aDecoder.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) RemoveObjectAtIndex(index NSUInteger)  {
	C.NSMutableArray_inst_RemoveObjectAtIndex(o.Ptr(), (C.NSUInteger)(index))
	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) 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) 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) 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) 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) 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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSMutableArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSMutableArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) FilterUsingPredicate(predicate *NSPredicate)  {
	C.NSMutableArray_inst_FilterUsingPredicate(o.Ptr(), predicate.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ScriptingContains(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSMutableArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) 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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) InsertObjectAtIndex(anObject NSObject, index NSUInteger)  {
	C.NSMutableArray_inst_InsertObjectAtIndex(o.Ptr(), anObject.Ptr(), (C.NSUInteger)(index))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObjectsInArray(otherArray *NSArray)  {
	C.NSMutableArray_inst_RemoveObjectsInArray(o.Ptr(), otherArray.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveAllObjects()  {
	C.NSMutableArray_inst_RemoveAllObjects(o.Ptr())
	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) 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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSMutableArray_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) IsEqualToArray(otherArray *NSArray) bool {
	ret := (C.NSMutableArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSMutableArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IsGreaterThan(object NSObject) bool {
	ret := (C.NSMutableArray_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSMutableArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

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) 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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) 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) RemoveObjectsInRange(range_ NSRange)  {
	C.NSMutableArray_inst_RemoveObjectsInRange(o.Ptr(), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSMutableArray_inst_ForwardInvocation(o.Ptr(), anInvocation.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) 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) 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) 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) 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) ReplaceObjectsAtIndexesWithObjects(indexes *NSIndexSet, objects *NSArray)  {
	C.NSMutableArray_inst_ReplaceObjectsAtIndexesWithObjects(o.Ptr(), indexes.Ptr(), objects.Ptr())
	runtime.KeepAlive(o)
}

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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSMutableArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ContainsObject(anObject NSObject) bool {
	ret := (C.NSMutableArray_inst_ContainsObject(o.Ptr(), anObject.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) AddObject(anObject NSObject)  {
	C.NSMutableArray_inst_AddObject(o.Ptr(), anObject.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) ReplaceObjectAtIndexWithObject(index NSUInteger, anObject NSObject)  {
	C.NSMutableArray_inst_ReplaceObjectAtIndexWithObject(o.Ptr(), (C.NSUInteger)(index), anObject.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSMutableArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) AddObjectsFromArray(otherArray *NSArray)  {
	C.NSMutableArray_inst_AddObjectsFromArray(o.Ptr(), otherArray.Ptr())
	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) 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) 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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) 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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) InitWithObjects(firstObj NSObject, objects ...NSObject) *NSMutableArray {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr(), unsafe.Pointer(&object)))
	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) 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) 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) 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) IsLessThan(object NSObject) bool {
	ret := (C.NSMutableArray_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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 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 NSEnumeratorAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSEnumerator_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func NSEnumeratorSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_Superclass()))
	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 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 NSEnumeratorHash() NSUInteger {
	ret := (NSUInteger)(C.NSEnumerator_Hash())
	return ret
}

func NSEnumeratorClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_Class()))
	return ret
}

func NSEnumeratorLoad()  {
	C.NSEnumerator_Load()
}

func NSEnumeratorSetVersion(aVersion NSInteger)  {
	C.NSEnumerator_SetVersion((C.NSInteger)(aVersion))
}

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 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 NSEnumeratorAccessInstanceVariablesDirectly() bool {
	ret := (C.NSEnumerator_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func NSEnumeratorDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_DebugDescription())
	if ret.ptr == nil { return ret }
	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 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 NSEnumeratorResolveClassMethod(sel SEL) bool {
	ret := (C.NSEnumerator_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSEnumeratorConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSEnumerator_ConformsToProtocol(protocol.Ptr())) != 0
	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 NSEnumeratorClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSEnumeratorVersion() NSInteger {
	ret := (NSInteger)(C.NSEnumerator_Version())
	return ret
}

func NSEnumeratorIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSEnumerator_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func NSEnumeratorResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSEnumerator_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSEnumeratorInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSEnumerator_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	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 (o *NSEnumerator) IsLessThan(object NSObject) bool {
	ret := (C.NSEnumerator_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSEnumerator_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) Dealloc()  {
	C.NSEnumerator_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) 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 (o *NSEnumerator) IsEqualTo(object NSObject) bool {
	ret := (C.NSEnumerator_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSEnumerator_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForArchiver(o.Ptr())))
	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) SetNilValueForKey(key *NSString)  {
	C.NSEnumerator_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

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) 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 := (C.NSEnumerator_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSEnumerator_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSEnumerator_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSEnumerator_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSEnumerator_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSEnumerator_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSEnumerator_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSEnumerator_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) DoesContain(object NSObject) bool {
	ret := (C.NSEnumerator_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSEnumerator_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForKeyedArchiver(o.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) 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) 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) 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) 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) 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) 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) 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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSEnumerator_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) 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) IsLike(object *NSString) bool {
	ret := (C.NSEnumerator_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) IsGreaterThan(object NSObject) bool {
	ret := (C.NSEnumerator_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSEnumerator_inst_ObservationInfo(o.Ptr())))
	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) 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) 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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSEnumerator_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) 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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSEnumerator_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) 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) 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) 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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSEnumerator_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingContains(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSEnumerator_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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 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 NSUUIDAccessInstanceVariablesDirectly() bool {
	ret := (C.NSUUID_AccessInstanceVariablesDirectly()) != 0
	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 NSUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSUUID_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func NSUUIDConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSUUID_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func NSUUIDHash() NSUInteger {
	ret := (NSUInteger)(C.NSUUID_Hash())
	return ret
}

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 NSUUIDClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_Class()))
	return ret
}

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 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 NSUUIDVersion() NSInteger {
	ret := (NSInteger)(C.NSUUID_Version())
	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 NSUUIDResolveClassMethod(sel SEL) bool {
	ret := (C.NSUUID_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	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 NSUUIDSetVersion(aVersion NSInteger)  {
	C.NSUUID_SetVersion((C.NSInteger)(aVersion))
}

func NSUUIDSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_Superclass()))
	return ret
}

func NSUUIDClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_ClassForKeyedUnarchiver()))
	return ret
}

func NSUUIDLoad()  {
	C.NSUUID_Load()
}

func NSUUIDClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_ClassFallbacksForKeyedArchiver())
	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 NSUUIDResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSUUID_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	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 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 NSUUIDSupportsSecureCoding() bool {
	ret := (C.NSUUID_SupportsSecureCoding()) != 0
	return ret
}

func NSUUIDInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func NSUUIDIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSUUID_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func (o *NSUUID) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) Dealloc()  {
	C.NSUUID_inst_Dealloc(o.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) IsGreaterThan(object NSObject) bool {
	ret := (C.NSUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) 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) 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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), 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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSUUID_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForCoder(o.Ptr())))
	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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) IsLike(object *NSString) bool {
	ret := (C.NSUUID_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) SetNilValueForKey(key *NSString)  {
	C.NSUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	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) 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) 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) IsLessThan(object NSObject) bool {
	ret := (C.NSUUID_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) DoesContain(object NSObject) bool {
	ret := (C.NSUUID_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingContains(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

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) 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) 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) 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) 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) 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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) 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) 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 := (C.NSUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) GetUUIDBytes(uuid *UnsignedChar)  {
	C.NSUUID_inst_GetUUIDBytes(o.Ptr(), unsafe.Pointer(uuid))
	runtime.KeepAlive(o)
}

func (o *NSUUID) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForArchiver(o.Ptr())))
	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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) IsEqualTo(object NSObject) bool {
	ret := (C.NSUUID_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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 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 CBAttributeSetVersion(aVersion NSInteger)  {
	C.CBAttribute_SetVersion((C.NSInteger)(aVersion))
}

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 CBAttributeClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_ClassForKeyedUnarchiver()))
	return ret
}

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 CBAttributeLoad()  {
	C.CBAttribute_Load()
}

func CBAttributeConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBAttribute_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func CBAttributeDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_DebugDescription())
	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 CBAttributeResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBAttribute_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBAttributeDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_Description())
	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 CBAttributeVersion() NSInteger {
	ret := (NSInteger)(C.CBAttribute_Version())
	return ret
}

func CBAttributeIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBAttribute_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func CBAttributeAccessInstanceVariablesDirectly() bool {
	ret := (C.CBAttribute_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBAttributeInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBAttribute_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func CBAttributeClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_Class()))
	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 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 CBAttributeClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBAttributeAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBAttribute_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func CBAttributeSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_Superclass()))
	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 CBAttributeResolveClassMethod(sel SEL) bool {
	ret := (C.CBAttribute_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBAttributeHash() NSUInteger {
	ret := (NSUInteger)(C.CBAttribute_Hash())
	return ret
}

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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBAttribute_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBAttribute_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	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) 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) 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) 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) 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) 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) DoesContain(object NSObject) bool {
	ret := (C.CBAttribute_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingContains(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBAttribute_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBAttribute_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) 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) IsLike(object *NSString) bool {
	ret := (C.CBAttribute_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBAttribute_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBAttribute_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsGreaterThan(object NSObject) bool {
	ret := (C.CBAttribute_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) 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 := (C.CBAttribute_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBAttribute_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBAttribute_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBAttribute_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) 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) 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) 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) 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) 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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBAttribute_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBAttribute_inst_ClassCode(o.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) 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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBAttribute_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) 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) 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) IsLessThan(object NSObject) bool {
	ret := (C.CBAttribute_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBAttribute_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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) IsEqualTo(object NSObject) bool {
	ret := (C.CBAttribute_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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 NSDictionaryConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSDictionary_ConformsToProtocol(protocol.Ptr())) != 0
	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 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 NSDictionaryDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionarySetVersion(aVersion NSInteger)  {
	C.NSDictionary_SetVersion((C.NSInteger)(aVersion))
}

func NSDictionaryWithContentsOfFile(path *NSString) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfFile(path.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryWithContentsOfURL(url *NSURL) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfURL(url.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	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 NSDictionaryResolveClassMethod(sel SEL) bool {
	ret := (C.NSDictionary_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSDictionaryDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_Description())
	if ret.ptr == nil { return ret }
	return ret
}

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 NSDictionaryHash() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_Hash())
	return ret
}

func NSDictionaryAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSDictionary_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	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 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 NSDictionaryKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_Class()))
	return ret
}

func NSDictionaryLoad()  {
	C.NSDictionary_Load()
}

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 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 NSDictionarySharedKeySetForKeys(keys *NSArray) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_SharedKeySetForKeys(keys.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionarySuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_Superclass()))
	return ret
}

func NSDictionaryClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_ClassForKeyedUnarchiver()))
	return ret
}

func NSDictionaryClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryWithObjectsAndKeys(firstObject NSObject, objects ...NSObject) *NSDictionary {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsAndKeys(firstObject.Ptr(), unsafe.Pointer(&object)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		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 NSDictionaryResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSDictionary_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	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 NSDictionaryIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSDictionary_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func NSDictionarySupportsSecureCoding() bool {
	ret := (C.NSDictionary_SupportsSecureCoding()) != 0
	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 NSDictionaryAccessInstanceVariablesDirectly() bool {
	ret := (C.NSDictionary_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func NSDictionaryInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSDictionary_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	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 NSDictionaryVersion() NSInteger {
	ret := (NSInteger)(C.NSDictionary_Version())
	return ret
}

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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSDictionary_inst_ClassCode(o.Ptr()))
	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) 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) 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) FileHFSTypeCode() OSType {
	ret := (OSType)(C.NSDictionary_inst_FileHFSTypeCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileIsImmutable() bool {
	ret := (C.NSDictionary_inst_FileIsImmutable(o.Ptr())) != 0
	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) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSDictionary_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

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) 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) 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) 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) 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) InitWithCoder(aDecoder *NSCoder) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithCoder(o.Ptr(), aDecoder.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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSDictionary_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSDictionary_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) FileSize() UnsignedLongLong {
	ret := (UnsignedLongLong)(C.NSDictionary_inst_FileSize(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) 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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) IsEqualTo(object NSObject) bool {
	ret := (C.NSDictionary_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForKeyedArchiver(o.Ptr())))
	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) 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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSDictionary_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ScriptingContains(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) IsLessThan(object NSObject) bool {
	ret := (C.NSDictionary_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) 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) FileExtensionHidden() bool {
	ret := (C.NSDictionary_inst_FileExtensionHidden(o.Ptr())) != 0
	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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSDictionary_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForArchiver(o.Ptr())))
	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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) InitWithContentsOfURL(url *NSURL) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfURL(o.Ptr(), url.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) 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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) SetNilValueForKey(key *NSString)  {
	C.NSDictionary_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) FileIsAppendOnly() bool {
	ret := (C.NSDictionary_inst_FileIsAppendOnly(o.Ptr())) != 0
	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) InitWithObjectsAndKeys(firstObject NSObject, objects ...NSObject) *NSDictionary {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsAndKeys(o.Ptr(), firstObject.Ptr(), unsafe.Pointer(&object)))
	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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSDictionary_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForCoder(o.Ptr())))
	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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSDictionary_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsLike(object *NSString) bool {
	ret := (C.NSDictionary_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) IsEqualToDictionary(otherDictionary *NSDictionary) bool {
	ret := (C.NSDictionary_inst_IsEqualToDictionary(o.Ptr(), otherDictionary.Ptr())) != 0
	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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSDictionary_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) DoesContain(object NSObject) bool {
	ret := (C.NSDictionary_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSDictionary_inst_ObservationInfo(o.Ptr())))
	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) 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) 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) 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) 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) 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) IsGreaterThan(object NSObject) bool {
	ret := (C.NSDictionary_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSDictionary_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithContentsOfFile(path *NSString) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfFile(o.Ptr(), path.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) 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) 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 := (C.NSDictionary_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSDictionary_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSDictionary_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSDictionary_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSDictionary_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) Count() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_inst_Count(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

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) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool {
	ret := (C.NSDictionary_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0
	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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSDictionary_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Dealloc()  {
	C.NSDictionary_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) 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 (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) 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) 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 := (C.NSDictionary_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 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) WriteToURLAtomically(url *NSURL, atomically BOOL) bool {
	ret := (C.NSDictionary_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0
	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) 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 NSObjectClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_Class()))
	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 NSObjectClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	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 NSObjectInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSObject_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func NSObjectVersion() NSInteger {
	ret := (NSInteger)(C.NSObject_Version())
	return ret
}

func NSObjectResolveClassMethod(sel SEL) bool {
	ret := (C.NSObject_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSObjectAccessInstanceVariablesDirectly() bool {
	ret := (C.NSObject_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func NSObjectLoad()  {
	C.NSObject_Load()
}

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 NSObjectDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSObjectSetVersion(aVersion NSInteger)  {
	C.NSObject_SetVersion((C.NSInteger)(aVersion))
}

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 NSObjectResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSObject_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSObjectSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_Superclass()))
	return ret
}

func NSObjectClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_ClassForKeyedUnarchiver()))
	return ret
}

func NSObjectConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSObject_ConformsToProtocol(protocol.Ptr())) != 0
	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 NSObjectAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSObject_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func NSObjectIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSObject_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

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 NSObjectDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_Description())
	if ret.ptr == nil { return ret }
	return ret
}

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 (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) 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) 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) 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) 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) 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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSObject_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) IsEqualTo(object NSObject) bool {
	ret := (C.NSObject_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsGreaterThan(object NSObject) bool {
	ret := (C.NSObject_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) DoesContain(object NSObject) bool {
	ret := (C.NSObject_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) SetNilValueForKey(key *NSString)  {
	C.NSObject_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) RespondsToSelector(aSelector SEL) bool {
	ret := (C.NSObject_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_Superclass(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSObject_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_Class(o.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) 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) 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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSObject_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) IsProxy() bool {
	ret := (C.NSObject_inst_IsProxy(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsMemberOfClass(aClass Class) bool {
	ret := (C.NSObject_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) 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) 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) ScriptingContains(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSObject_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSObject_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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 := (C.NSObject_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSObject_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSObject_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSObject_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) 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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) IsLike(object *NSString) bool {
	ret := (C.NSObject_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) Dealloc()  {
	C.NSObject_inst_Dealloc(o.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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSObject_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) IsLessThan(object NSObject) bool {
	ret := (C.NSObject_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (C.NSObject_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0
	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) Release()  {
	C.NSObject_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) IsEqual(object NSObject) bool {
	ret := (C.NSObject_inst_IsEqual(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Hash() NSUInteger {
	ret := (NSUInteger)(C.NSObject_inst_Hash(o.Ptr()))
	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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSObject_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForCoder(o.Ptr())))
	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) 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) 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) 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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSObject_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSObject_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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 (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) 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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSObject_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	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) 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) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.NSObject_inst_Zone(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) 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) 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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSObject_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSObject_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsKindOfClass(aClass Class) bool {
	ret := (C.NSObject_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	runtime.KeepAlive(o)
	return ret
}

func NSDataClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSData_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	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 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 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 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 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 NSDataClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_ClassForKeyedUnarchiver()))
	return ret
}

func NSDataHash() NSUInteger {
	ret := (NSUInteger)(C.NSData_Hash())
	return ret
}

func NSDataIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSData_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	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 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 NSDataVersion() NSInteger {
	ret := (NSInteger)(C.NSData_Version())
	return ret
}

func NSDataResolveClassMethod(sel SEL) bool {
	ret := (C.NSData_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

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 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 NSDataResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSData_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSDataSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_Superclass()))
	return ret
}

func NSDataDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataAccessInstanceVariablesDirectly() bool {
	ret := (C.NSData_AccessInstanceVariablesDirectly()) != 0
	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 NSDataSupportsSecureCoding() bool {
	ret := (C.NSData_SupportsSecureCoding()) != 0
	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 NSDataDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataSetVersion(aVersion NSInteger)  {
	C.NSData_SetVersion((C.NSInteger)(aVersion))
}

func NSDataClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_Class()))
	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 := (C.NSData_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func NSDataConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSData_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func NSDataAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSData_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

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 NSDataKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSData_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataLoad()  {
	C.NSData_Load()
}

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) 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) 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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) 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) 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) 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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForCoder(o.Ptr())))
	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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSData_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) Release()  {
	C.NSData_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

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) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (C.NSData_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0
	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) 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) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool {
	ret := (C.NSData_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0
	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 := (C.NSData_inst_WriteToFileOptions(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSData_inst_WriteToFileOptionsError(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) SetNilValueForKey(key *NSString)  {
	C.NSData_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) IsLessThan(object NSObject) bool {
	ret := (C.NSData_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSData_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.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) 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) 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) 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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForKeyedArchiver(o.Ptr())))
	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) 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) 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) IsEqualToData(other *NSData) bool {
	ret := (C.NSData_inst_IsEqualToData(o.Ptr(), other.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSData_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) RespondsToSelector(aSelector SEL) bool {
	ret := (C.NSData_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0
	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) 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) 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 := (C.NSData_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSData_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSData_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSData_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) ScriptingContains(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.NSData_inst_Zone(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) 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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSData_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsEqual(object NSObject) bool {
	ret := (C.NSData_inst_IsEqual(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) WriteToURLAtomically(url *NSURL, atomically BOOL) bool {
	ret := (C.NSData_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0
	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 := (C.NSData_inst_WriteToURLOptions(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSData_inst_WriteToURLOptionsError(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) 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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSData_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

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) Length() NSUInteger {
	ret := (NSUInteger)(C.NSData_inst_Length(o.Ptr()))
	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) 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) 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) 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) Bytes() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSData_inst_Bytes(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 (o *NSData) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsLike(object *NSString) bool {
	ret := (C.NSData_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSData_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) IsGreaterThan(object NSObject) bool {
	ret := (C.NSData_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) DoesContain(object NSObject) bool {
	ret := (C.NSData_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Dealloc()  {
	C.NSData_inst_Dealloc(o.Ptr())
	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) IsKindOfClass(aClass Class) bool {
	ret := (C.NSData_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSData_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSData_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSData_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

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) IsEqualTo(object NSObject) bool {
	ret := (C.NSData_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSData_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSData_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsProxy() bool {
	ret := (C.NSData_inst_IsProxy(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsMemberOfClass(aClass Class) bool {
	ret := (C.NSData_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSData_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func CBManagerIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

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 CBManagerAccessInstanceVariablesDirectly() bool {
	ret := (C.CBManager_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBManagerSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_Superclass()))
	return ret
}

func CBManagerHash() NSUInteger {
	ret := (NSUInteger)(C.CBManager_Hash())
	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 CBManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func CBManagerDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_Description())
	if ret.ptr == nil { return ret }
	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 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 CBManagerInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func CBManagerSetVersion(aVersion NSInteger)  {
	C.CBManager_SetVersion((C.NSInteger)(aVersion))
}

func CBManagerResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBManagerClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_ClassForKeyedUnarchiver()))
	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 CBManagerClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_Class()))
	return ret
}

func CBManagerClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

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 CBManagerResolveClassMethod(sel SEL) bool {
	ret := (C.CBManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBManagerDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBManagerConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBManager_ConformsToProtocol(protocol.Ptr())) != 0
	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 CBManagerVersion() NSInteger {
	ret := (NSInteger)(C.CBManager_Version())
	return ret
}

func CBManagerLoad()  {
	C.CBManager_Load()
}

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 (o *CBManager) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (C.CBManager_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0
	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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_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 *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) 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) 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) 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) DoesContain(object NSObject) bool {
	ret := (C.CBManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) RespondsToSelector(aSelector SEL) bool {
	ret := (C.CBManager_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0
	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) IsEqual(object NSObject) bool {
	ret := (C.CBManager_inst_IsEqual(o.Ptr(), object.Ptr())) != 0
	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) 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) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.CBManager_inst_Zone(o.Ptr())))
	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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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 (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) 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) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_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 *CBManager) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_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 *CBManager) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_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 *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) 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) 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) 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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForKeyedArchiver(o.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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBManager_inst_ClassCode(o.Ptr()))
	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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsEqualTo(object NSObject) bool {
	ret := (C.CBManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) Self() *CBManager {
	ret := &CBManager{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_Self(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBManager) {
		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) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_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 *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) 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) 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) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_Class(o.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) IsMemberOfClass(aClass Class) bool {
	ret := (C.CBManager_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) 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) IsLike(object *NSString) bool {
	ret := (C.CBManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	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) 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) Retain() *CBManager {
	ret := &CBManager{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_Retain(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsGreaterThan(object NSObject) bool {
	ret := (C.CBManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) 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) SetNilValueForKey(key *NSString)  {
	C.CBManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) IsLessThan(object NSObject) bool {
	ret := (C.CBManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) 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 := (C.CBManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) Hash() NSUInteger {
	ret := (NSUInteger)(C.CBManager_inst_Hash(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.CBManager_inst_RetainCount(o.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) 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) ScriptingContains(object NSObject) bool {
	ret := (C.CBManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsKindOfClass(aClass Class) bool {
	ret := (C.CBManager_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) Dealloc()  {
	C.CBManager_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) Release()  {
	C.CBManager_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

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) State() CBManagerState {
	ret := (CBManagerState)(C.CBManager_inst_State(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_Superclass(o.Ptr())))
	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) Autorelease() *CBManager {
	ret := &CBManager{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_Autorelease(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBManager) {
		o.Release()
	})
	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) 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) IsProxy() bool {
	ret := (C.CBManager_inst_IsProxy(o.Ptr())) != 0
	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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBManager) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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 CBCentralManagerClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_Class()))
	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 CBCentralManagerIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBCentralManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

func CBCentralManagerAccessInstanceVariablesDirectly() bool {
	ret := (C.CBCentralManager_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBCentralManagerHash() NSUInteger {
	ret := (NSUInteger)(C.CBCentralManager_Hash())
	return ret
}

func CBCentralManagerDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_Description())
	if ret.ptr == nil { return ret }
	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 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 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 CBCentralManagerDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_DebugDescription())
	if ret.ptr == nil { return ret }
	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 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 CBCentralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBCentralManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func CBCentralManagerResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBCentralManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBCentralManagerClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralManagerResolveClassMethod(sel SEL) bool {
	ret := (C.CBCentralManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBCentralManagerConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBCentralManager_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func CBCentralManagerVersion() NSInteger {
	ret := (NSInteger)(C.CBCentralManager_Version())
	return ret
}

func CBCentralManagerLoad()  {
	C.CBCentralManager_Load()
}

func CBCentralManagerSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_Superclass()))
	return ret
}

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 CBCentralManagerInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBCentralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func CBCentralManagerSetVersion(aVersion NSInteger)  {
	C.CBCentralManager_SetVersion((C.NSInteger)(aVersion))
}

func CBCentralManagerClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_ClassForKeyedUnarchiver()))
	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) 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) 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 (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 := (C.CBCentralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCentralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCentralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCentralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) IsKindOfClass(aClass Class) bool {
	ret := (C.CBCentralManager_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) RespondsToSelector(aSelector SEL) bool {
	ret := (C.CBCentralManager_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBCentralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (C.CBCentralManager_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_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 *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) 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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) State() CBManagerState {
	ret := (CBManagerState)(C.CBCentralManager_inst_State(o.Ptr()))
	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) IsEqual(object NSObject) bool {
	ret := (C.CBCentralManager_inst_IsEqual(o.Ptr(), object.Ptr())) != 0
	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) 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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForArchiver(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) IsScanning() bool {
	ret := (C.CBCentralManager_inst_IsScanning(o.Ptr())) != 0
	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) 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) 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) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBCentralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.CBCentralManager_inst_Zone(o.Ptr())))
	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) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_Superclass(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) StopScan()  {
	C.CBCentralManager_inst_StopScan(o.Ptr())
	runtime.KeepAlive(o)
}

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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBCentralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) Dealloc()  {
	C.CBCentralManager_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

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) ScanForPeripheralsWithServices(serviceUUIDs *NSArray, options *NSDictionary)  {
	C.CBCentralManager_inst_ScanForPeripheralsWithServices(o.Ptr(), serviceUUIDs.Ptr(), options.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) ConnectPeripheral(peripheral *CBPeripheral, options *NSDictionary)  {
	C.CBCentralManager_inst_ConnectPeripheral(o.Ptr(), peripheral.Ptr(), options.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBCentralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsLessThan(object NSObject) bool {
	ret := (C.CBCentralManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_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 *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) 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) IsLike(object *NSString) bool {
	ret := (C.CBCentralManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.CBCentralManager_inst_RetainCount(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) IsGreaterThan(object NSObject) bool {
	ret := (C.CBCentralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBCentralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBCentralManager_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	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) IsProxy() bool {
	ret := (C.CBCentralManager_inst_IsProxy(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBCentralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) Release()  {
	C.CBCentralManager_inst_Release(o.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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBCentralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsEqualTo(object NSObject) bool {
	ret := (C.CBCentralManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) SetDelegate(delegate NSObject)  {
	C.CBCentralManager_inst_SetDelegate(o.Ptr(), delegate.Ptr())
	runtime.KeepAlive(o)
}

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) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_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 *CBCentralManager) DoesContain(object NSObject) bool {
	ret := (C.CBCentralManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) Self() *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Self(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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) CancelPeripheralConnection(peripheral *CBPeripheral)  {
	C.CBCentralManager_inst_CancelPeripheralConnection(o.Ptr(), peripheral.Ptr())
	runtime.KeepAlive(o)
}

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) 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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) Autorelease() *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Autorelease(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) IsMemberOfClass(aClass Class) bool {
	ret := (C.CBCentralManager_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingContains(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBCentralManager_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) Hash() NSUInteger {
	ret := (NSUInteger)(C.CBCentralManager_inst_Hash(o.Ptr()))
	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) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_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 *CBCentralManager) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_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 *CBCentralManager) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_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 *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) 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) 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) 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)  {
	C.CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	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) 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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBCentralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBCentralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) Retain() *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Retain(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 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 CBCentralSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_Superclass()))
	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 CBCentralInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.CBCentral_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func CBCentralResolveClassMethod(sel SEL) bool {
	ret := (C.CBCentral_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBCentralLoad()  {
	C.CBCentral_Load()
}

func CBCentralClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_ClassForKeyedUnarchiver()))
	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 CBCentralClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_Class()))
	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 CBCentralSetVersion(aVersion NSInteger)  {
	C.CBCentral_SetVersion((C.NSInteger)(aVersion))
}

func CBCentralResolveInstanceMethod(sel SEL) bool {
	ret := (C.CBCentral_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func CBCentralConformsToProtocol(protocol Protocol) bool {
	ret := (C.CBCentral_ConformsToProtocol(protocol.Ptr())) != 0
	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 CBCentralAccessInstanceVariablesDirectly() bool {
	ret := (C.CBCentral_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func CBCentralVersion() NSInteger {
	ret := (NSInteger)(C.CBCentral_Version())
	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 CBCentralDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentral_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralHash() NSUInteger {
	ret := (NSUInteger)(C.CBCentral_Hash())
	return ret
}

func CBCentralAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.CBCentral_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	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 CBCentralKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBCentral_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralIsSubclassOfClass(aClass Class) bool {
	ret := (C.CBCentral_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	return ret
}

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 (o *CBCentral) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsMemberOfClass(aClass Class) bool {
	ret := (C.CBCentral_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) 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) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.CBCentral_inst_RetainCount(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) 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) 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) ScriptingContains(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCentral_inst_ObservationInfo(o.Ptr())))
	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 := (C.CBCentral_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCentral_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCentral_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.CBCentral_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) 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) IsLike(object *NSString) bool {
	ret := (C.CBCentral_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) IsProxy() bool {
	ret := (C.CBCentral_inst_IsProxy(o.Ptr())) != 0
	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) Release()  {
	C.CBCentral_inst_Release(o.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) IsEqualTo(object NSObject) bool {
	ret := (C.CBCentral_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBCentral_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentral) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForKeyedArchiver(o.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) 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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) DoesContain(object NSObject) bool {
	ret := (C.CBCentral_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsGreaterThan(object NSObject) bool {
	ret := (C.CBCentral_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsLessThan(object NSObject) bool {
	ret := (C.CBCentral_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBCentral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBCentral_inst_ClassCode(o.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) SetNilValueForKey(key *NSString)  {
	C.CBCentral_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) 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) 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) 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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) Dealloc()  {
	C.CBCentral_inst_Dealloc(o.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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) 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) 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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.CBCentral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) RespondsToSelector(aSelector SEL) bool {
	ret := (C.CBCentral_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0
	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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) IsNotEqualTo(object NSObject) bool {
	ret := (C.CBCentral_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBCentral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) IsEqual(object NSObject) bool {
	ret := (C.CBCentral_inst_IsEqual(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.CBCentral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.CBCentral_inst_Zone(o.Ptr())))
	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) IsKindOfClass(aClass Class) bool {
	ret := (C.CBCentral_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) 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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBCentral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (C.CBCentral_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0
	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) 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) 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) MaximumUpdateValueLength() NSUInteger {
	ret := (NSUInteger)(C.CBCentral_inst_MaximumUpdateValueLength(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.CBCentral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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 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 NSStringWritableTypeIdentifiersForItemProvider() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_WritableTypeIdentifiersForItemProvider())
	if ret.ptr == nil { return ret }
	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 NSStringKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSString_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringLoad()  {
	C.NSString_Load()
}

func NSStringSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_Superclass()))
	return ret
}

func NSStringDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringLocalizedStringWithFormat(format *NSString, objects ...NSObject) *NSString {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_LocalizedStringWithFormat(format.Ptr(), unsafe.Pointer(&object)))
	if ret.ptr == nil { return ret }
	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 NSStringInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSString_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func NSStringHash() NSUInteger {
	ret := (NSUInteger)(C.NSString_Hash())
	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 NSStringAvailableStringEncodings() *NSStringEncoding {
	ret := (*NSStringEncoding)(unsafe.Pointer(C.NSString_AvailableStringEncodings()))
	return ret
}

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 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 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 NSStringConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSString_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func NSStringAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSString_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	return ret
}

func NSStringItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility {
	ret := (NSItemProviderRepresentationVisibility)(C.NSString_ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier.Ptr()))
	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 NSStringClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_Class()))
	return ret
}

func NSStringAccessInstanceVariablesDirectly() bool {
	ret := (C.NSString_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func NSStringClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_ClassForKeyedUnarchiver()))
	return ret
}

func NSStringVersion() NSInteger {
	ret := (NSInteger)(C.NSString_Version())
	return ret
}

func NSStringResolveClassMethod(sel SEL) bool {
	ret := (C.NSString_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSStringDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringSetVersion(aVersion NSInteger)  {
	C.NSString_SetVersion((C.NSInteger)(aVersion))
}

func NSStringDefaultCStringEncoding() NSStringEncoding {
	ret := (NSStringEncoding)(C.NSString_DefaultCStringEncoding())
	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 NSStringPathWithComponents(components *NSArray) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_PathWithComponents(components.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSString_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSStringIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSString_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	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 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 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 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 NSStringReadableTypeIdentifiersForItemProvider() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_ReadableTypeIdentifiersForItemProvider())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	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 NSStringSupportsSecureCoding() bool {
	ret := (C.NSString_SupportsSecureCoding()) != 0
	return ret
}

func NSStringWithFormat(format *NSString, objects ...NSObject) *NSString {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithFormat(format.Ptr(), unsafe.Pointer(&object)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	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 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 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 (o *NSString) Hash() NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_Hash(o.Ptr()))
	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) LocalizedStandardRangeOfString(str *NSString) NSRange {
	ret := (NSRange)(C.NSString_inst_LocalizedStandardRangeOfString(o.Ptr(), str.Ptr()))
	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) 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) 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) 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) 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) 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) 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) 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) 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) SmallestEncoding() NSStringEncoding {
	ret := (NSStringEncoding)(C.NSString_inst_SmallestEncoding(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

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) 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) RangeOfComposedCharacterSequencesForRange(range_ NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequencesForRange(o.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsLike(object *NSString) bool {
	ret := (C.NSString_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSString_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) BoolValue() bool {
	ret := (C.NSString_inst_BoolValue(o.Ptr())) != 0
	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) 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) 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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSString_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	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) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_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 *NSString) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_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 *NSString) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_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 *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) 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) 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) 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) 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 := (C.NSString_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSString_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSString_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSString_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) 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) GetCStringMaxLength(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool {
	ret := (C.NSString_inst_GetCStringMaxLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding))) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetCStringMaxLengthEncoding(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool {
	ret := (C.NSString_inst_GetCStringMaxLengthEncoding(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding))) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Autorelease() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_Autorelease(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) 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) UTF8String() *Char {
	ret := (*Char)(unsafe.Pointer(C.NSString_inst_UTF8String(o.Ptr())))
	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) 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) 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) 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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForCoder(o.Ptr())))
	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) 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) HasSuffix(str *NSString) bool {
	ret := (C.NSString_inst_HasSuffix(o.Ptr(), str.Ptr())) != 0
	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) LocalizedStandardContainsString(str *NSString) bool {
	ret := (C.NSString_inst_LocalizedStandardContainsString(o.Ptr(), str.Ptr())) != 0
	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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	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) 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 (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) CharacterAtIndex(index NSUInteger) Unichar {
	ret := (Unichar)(C.NSString_inst_CharacterAtIndex(o.Ptr(), (C.NSUInteger)(index)))
	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) 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 := (C.NSString_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 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 := (C.NSString_inst_WriteToFileAtomicallyEncoding(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 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) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (C.NSString_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) HasPrefix(str *NSString) bool {
	ret := (C.NSString_inst_HasPrefix(o.Ptr(), str.Ptr())) != 0
	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) 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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSString_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) 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) 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) 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) 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) IsKindOfClass(aClass Class) bool {
	ret := (C.NSString_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSString_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) RespondsToSelector(aSelector SEL) bool {
	ret := (C.NSString_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0
	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) FastestEncoding() NSStringEncoding {
	ret := (NSStringEncoding)(C.NSString_inst_FastestEncoding(o.Ptr()))
	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) 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) LinguisticTagsInRangeScheme(range_ NSRange, scheme NSLinguisticTagScheme, options NSLinguisticTaggerOptions, orthography *NSOrthography, tokenRanges *[]*NSArray) *NSArray {

	goSlice5 := make([]unsafe.Pointer,cap(*tokenRanges))
	for i := 0; i < len(*tokenRanges); i++ {
		goSlice5[i] = (*tokenRanges)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LinguisticTagsInRangeScheme(o.Ptr(), (C.NSRange)(range_), scheme.Ptr(), (C.NSLinguisticTaggerOptions)(options), orthography.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice5[0]))))
	(*tokenRanges) = (*tokenRanges)[:cap(*tokenRanges)]
	for i := 0; i < len(*tokenRanges); i++ {
		if goSlice5[i] == nil {
			(*tokenRanges) = (*tokenRanges)[:i]
			break
		}
		if (*tokenRanges)[i] == nil {
			(*tokenRanges)[i] = &NSArray{}
			runtime.SetFinalizer((*tokenRanges)[i], func(o *NSArray) {
				o.Release()
			})
		}
		(*tokenRanges)[i].ptr = goSlice5[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 *NSString) LinguisticTagsInRangeSchemeOptions(range_ NSRange, scheme NSLinguisticTagScheme, options NSLinguisticTaggerOptions, orthography *NSOrthography, tokenRanges *[]*NSArray) *NSArray {

	goSlice5 := make([]unsafe.Pointer,cap(*tokenRanges))
	for i := 0; i < len(*tokenRanges); i++ {
		goSlice5[i] = (*tokenRanges)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LinguisticTagsInRangeSchemeOptions(o.Ptr(), (C.NSRange)(range_), scheme.Ptr(), (C.NSLinguisticTaggerOptions)(options), orthography.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice5[0]))))
	(*tokenRanges) = (*tokenRanges)[:cap(*tokenRanges)]
	for i := 0; i < len(*tokenRanges); i++ {
		if goSlice5[i] == nil {
			(*tokenRanges) = (*tokenRanges)[:i]
			break
		}
		if (*tokenRanges)[i] == nil {
			(*tokenRanges)[i] = &NSArray{}
			runtime.SetFinalizer((*tokenRanges)[i], func(o *NSArray) {
				o.Release()
			})
		}
		(*tokenRanges)[i].ptr = goSlice5[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 *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) 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) 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) 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) 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) 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) 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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) SetNilValueForKey(key *NSString)  {
	C.NSString_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) Self() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_Self(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) 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) LongLongValue() LongLong {
	ret := (LongLong)(C.NSString_inst_LongLongValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Dealloc()  {
	C.NSString_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_RetainCount(o.Ptr()))
	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) Length() NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_Length(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByAppendingFormat(format *NSString, objects ...NSObject) *NSString {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingFormat(o.Ptr(), format.Ptr(), unsafe.Pointer(&object)))
	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) ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility {
	ret := (NSItemProviderRepresentationVisibility)(C.NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(o.Ptr(), typeIdentifier.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetBytesMaxLength(buffer unsafe.Pointer, maxBufferCount NSUInteger, usedBufferCount *NSUInteger, encoding NSStringEncoding, options NSStringEncodingConversionOptions, range_ NSRange, leftover NSRangePointer) bool {
	ret := (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))) != 0
	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 := (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))) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) ParagraphRangeForRange(range_ NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_ParagraphRangeForRange(o.Ptr(), (C.NSRange)(range_)))
	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) 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) CaseInsensitiveCompare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_CaseInsensitiveCompare(o.Ptr(), string.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) 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) RangeOfComposedCharacterSequenceAtIndex(index NSUInteger) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequenceAtIndex(o.Ptr(), (C.NSUInteger)(index)))
	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) 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) InitWithBytesNoCopyLengthEncoding(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding, freeBuffer BOOL) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesNoCopyLengthEncoding(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) LengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_LengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc)))
	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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSString_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) 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) DoesContain(object NSObject) bool {
	ret := (C.NSString_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ContainsString(str *NSString) bool {
	ret := (C.NSString_inst_ContainsString(o.Ptr(), str.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsProxy() bool {
	ret := (C.NSString_inst_IsProxy(o.Ptr())) != 0
	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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) IsMemberOfClass(aClass Class) bool {
	ret := (C.NSString_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) 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) 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) 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) Retain() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_Retain(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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) InitWithCoder(aDecoder *NSCoder) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCoder(o.Ptr(), aDecoder.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) LineRangeForRange(range_ NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_LineRangeForRange(o.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSString_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingContains(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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) IntegerValue() NSInteger {
	ret := (NSInteger)(C.NSString_inst_IntegerValue(o.Ptr()))
	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 := (C.NSString_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 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 := (C.NSString_inst_WriteToURLAtomicallyEncoding(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 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) IsAbsolutePath() bool {
	ret := (C.NSString_inst_IsAbsolutePath(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsEqualTo(object NSObject) bool {
	ret := (C.NSString_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsLessThan(object NSObject) bool {
	ret := (C.NSString_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

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) 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) 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) 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) GetFileSystemRepresentationMaxLength(cname *Char, max NSUInteger) bool {
	ret := (C.NSString_inst_GetFileSystemRepresentationMaxLength(o.Ptr(), unsafe.Pointer(cname), (C.NSUInteger)(max))) != 0
	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) 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) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.NSString_inst_Zone(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) 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) MaximumLengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_MaximumLengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc)))
	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) 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) 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) LocalizedCaseInsensitiveCompare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_LocalizedCaseInsensitiveCompare(o.Ptr(), string.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Release()  {
	C.NSString_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

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) 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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSString_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

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) 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) FloatValue() Float {
	ret := (Float)(C.NSString_inst_FloatValue(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) 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) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_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 *NSString) IsEqual(object NSObject) bool {
	ret := (C.NSString_inst_IsEqual(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_inst_Class(o.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) InitWithFormat(format *NSString, objects ...NSObject) *NSString {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormat(o.Ptr(), format.Ptr(), unsafe.Pointer(&object)))
	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, objects ...NSObject) *NSString {
	var object [16]unsafe.Pointer
	for i,o := range objects {
		object[i] = o.Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormatLocale(o.Ptr(), format.Ptr(), locale.Ptr(), unsafe.Pointer(&object)))
	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 := (C.NSString_inst_LocalizedCaseInsensitiveContainsString(o.Ptr(), str.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsGreaterThan(object NSObject) bool {
	ret := (C.NSString_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	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) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) CanBeConvertedToEncoding(encoding NSStringEncoding) bool {
	ret := (C.NSString_inst_CanBeConvertedToEncoding(o.Ptr(), (C.NSStringEncoding)(encoding))) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsEqualToString(aString *NSString) bool {
	ret := (C.NSString_inst_IsEqualToString(o.Ptr(), aString.Ptr())) != 0
	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) LocalizedStandardCompare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_LocalizedStandardCompare(o.Ptr(), string.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) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSString_inst_ClassCode(o.Ptr()))
	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) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_inst_Superclass(o.Ptr())))
	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) 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSString_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSString_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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 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 NSNumberKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSNumber_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	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 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 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 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 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 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 NSNumberDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberLoad()  {
	C.NSNumber_Load()
}

func NSNumberDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_Superclass()))
	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 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 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 NSNumberResolveClassMethod(sel SEL) bool {
	ret := (C.NSNumber_ResolveClassMethod(unsafe.Pointer(sel))) != 0
	return ret
}

func NSNumberClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberConformsToProtocol(protocol Protocol) bool {
	ret := (C.NSNumber_ConformsToProtocol(protocol.Ptr())) != 0
	return ret
}

func NSNumberHash() NSUInteger {
	ret := (NSUInteger)(C.NSNumber_Hash())
	return ret
}

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 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 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 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 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 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 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 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 NSNumberInstancesRespondToSelector(aSelector SEL) bool {
	ret := (C.NSNumber_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0
	return ret
}

func NSNumberClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_ClassForKeyedUnarchiver()))
	return ret
}

func NSNumberIsSubclassOfClass(aClass Class) bool {
	ret := (C.NSNumber_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0
	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 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 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 NSNumberVersion() NSInteger {
	ret := (NSInteger)(C.NSNumber_Version())
	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 NSNumberResolveInstanceMethod(sel SEL) bool {
	ret := (C.NSNumber_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0
	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 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 NSNumberClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_Class()))
	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 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 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 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 NSNumberSetVersion(aVersion NSInteger)  {
	C.NSNumber_SetVersion((C.NSInteger)(aVersion))
}

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 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 NSNumberAccessInstanceVariablesDirectly() bool {
	ret := (C.NSNumber_AccessInstanceVariablesDirectly()) != 0
	return ret
}

func NSNumberAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (C.NSNumber_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0
	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) 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) ScriptingIsEqualTo(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) UnsignedCharValue() UnsignedChar {
	ret := (UnsignedChar)(C.NSNumber_inst_UnsignedCharValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.NSNumber_inst_RetainCount(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) 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) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSNumber_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

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) 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) 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) RectValue() NSRect {
	ret := (NSRect)(C.NSNumber_inst_RectValue(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) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_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 *NSNumber) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_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 *NSNumber) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_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 *NSNumber) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_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 *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) 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) 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) 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) 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) ScriptingBeginsWith(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0
	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) IsEqualToNumber(number *NSNumber) bool {
	ret := (C.NSNumber_inst_IsEqualToNumber(o.Ptr(), number.Ptr())) != 0
	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) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ReplacementObjectForCoder(aCoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) 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) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSNumber_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

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) 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) UnsignedIntegerValue() NSUInteger {
	ret := (NSUInteger)(C.NSNumber_inst_UnsignedIntegerValue(o.Ptr()))
	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) 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) UnsignedLongLongValue() UnsignedLongLong {
	ret := (UnsignedLongLong)(C.NSNumber_inst_UnsignedLongLongValue(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) 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) 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) ScriptingIsLessThan(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_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 *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) UnsignedIntValue() UnsignedInt {
	ret := (UnsignedInt)(C.NSNumber_inst_UnsignedIntValue(o.Ptr()))
	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) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0
	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) 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) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSNumber_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

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) IsGreaterThan(object NSObject) bool {
	ret := (C.NSNumber_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) Release()  {
	C.NSNumber_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

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) DoubleValue() Double {
	ret := (Double)(C.NSNumber_inst_DoubleValue(o.Ptr()))
	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) 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) IsKindOfClass(aClass Class) bool {
	ret := (C.NSNumber_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	runtime.KeepAlive(o)
	return ret
}

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) SetNilValueForKey(key *NSString)  {
	C.NSNumber_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

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) 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) DoesContain(object NSObject) bool {
	ret := (C.NSNumber_inst_DoesContain(o.Ptr(), object.Ptr())) != 0
	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) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSNumber_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

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) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (C.NSNumber_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0
	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) 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) ObjCType() *Char {
	ret := (*Char)(unsafe.Pointer(C.NSNumber_inst_ObjCType(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsEqualToValue(value *NSValue) bool {
	ret := (C.NSNumber_inst_IsEqualToValue(o.Ptr(), value.Ptr())) != 0
	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) IntValue() Int {
	ret := (Int)(C.NSNumber_inst_IntValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsNotEqualTo(object NSObject) bool {
	ret := (C.NSNumber_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsProxy() bool {
	ret := (C.NSNumber_inst_IsProxy(o.Ptr())) != 0
	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) IsMemberOfClass(aClass Class) bool {
	ret := (C.NSNumber_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0
	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) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.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) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (C.NSNumber_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0
	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) 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) 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) UnsignedShortValue() UnsignedShort {
	ret := (UnsignedShort)(C.NSNumber_inst_UnsignedShortValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) Autorelease() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_Autorelease(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) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_Superclass(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingContains(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0
	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 := (C.NSNumber_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSNumber_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSNumber_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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 := (C.NSNumber_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 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) IsEqual(object NSObject) bool {
	ret := (C.NSNumber_inst_IsEqual(o.Ptr(), object.Ptr())) != 0
	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) InitWithCoder(aDecoder *NSCoder) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithCoder(o.Ptr(), aDecoder.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) 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) SizeValue() NSSize {
	ret := (NSSize)(C.NSNumber_inst_SizeValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsLike(object *NSString) bool {
	ret := (C.NSNumber_inst_IsLike(o.Ptr(), object.Ptr())) != 0
	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) ShortValue() Short {
	ret := (Short)(C.NSNumber_inst_ShortValue(o.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) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForArchiver(o.Ptr())))
	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) 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) Self() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_Self(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) LongLongValue() LongLong {
	ret := (LongLong)(C.NSNumber_inst_LongLongValue(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) 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) 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) 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) EdgeInsetsValue() NSEdgeInsets {
	ret := (NSEdgeInsets)(C.NSNumber_inst_EdgeInsetsValue(o.Ptr()))
	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) UnsignedLongValue() UnsignedLong {
	ret := (UnsignedLong)(C.NSNumber_inst_UnsignedLongValue(o.Ptr()))
	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) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) 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) 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) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_ObservationInfo(o.Ptr())))
	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) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.NSNumber_inst_Zone(o.Ptr())))
	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) PointerValue() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_PointerValue(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) Hash() NSUInteger {
	ret := (NSUInteger)(C.NSNumber_inst_Hash(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) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSNumber_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

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) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForKeyedArchiver(o.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) 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) 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) Retain() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_Retain(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) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

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) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (C.NSNumber_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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) 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) IsEqualTo(object NSObject) bool {
	ret := (C.NSNumber_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0
	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) Dealloc()  {
	C.NSNumber_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) IsLessThan(object NSObject) bool {
	ret := (C.NSNumber_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0
	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) RangeValue() NSRange {
	ret := (NSRange)(C.NSNumber_inst_RangeValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) GetValue(value unsafe.Pointer)  {
	C.NSNumber_inst_GetValue(o.Ptr(), unsafe.Pointer(value))
	runtime.KeepAlive(o)
}

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) 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) 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) ScriptingEndsWith(object NSObject) bool {
	ret := (C.NSNumber_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) BoolValue() bool {
	ret := (C.NSNumber_inst_BoolValue(o.Ptr())) != 0
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) RespondsToSelector(aSelector SEL) bool {
	ret := (C.NSNumber_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0
	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) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (C.NSNumber_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0
	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 { 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 {
	CentralManagerDidUpdateState func(*CBCentralManager, )
	CentralManagerDidConnectPeripheral func(*CBCentralManager, *CBPeripheral, )
	CentralManagerDidDisconnectPeripheral func(*CBCentralManager, *CBPeripheral, *NSError, )
	CentralManagerDidDiscoverPeripheral func(*CBCentralManager, *CBPeripheral, *NSDictionary, *NSNumber, )
	PeripheralDidDiscoverServices func(*CBPeripheral, *NSError, )
	PeripheralDidDiscoverCharacteristicsForService func(*CBPeripheral, *CBService, *NSError, )
	PeripheralDidUpdateValueForCharacteristic func(*CBPeripheral, *CBCharacteristic, *NSError, )
}
var CBDelegateLookup = map[unsafe.Pointer]CBDelegateDispatch{}
var CBDelegateMux sync.RWMutex

func (d CBDelegate) CentralManagerDidUpdateStateCallback(f func(*CBCentralManager, )) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidUpdateState = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) CentralManagerDidConnectPeripheralCallback(f func(*CBCentralManager, *CBPeripheral, )) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidConnectPeripheral = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) CentralManagerDidDisconnectPeripheralCallback(f func(*CBCentralManager, *CBPeripheral, *NSError, )) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidDisconnectPeripheral = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) CentralManagerDidDiscoverPeripheralCallback(f func(*CBCentralManager, *CBPeripheral, *NSDictionary, *NSNumber, )) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidDiscoverPeripheral = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) PeripheralDidDiscoverServicesCallback(f func(*CBPeripheral, *NSError, )) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.PeripheralDidDiscoverServices = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) PeripheralDidDiscoverCharacteristicsForServiceCallback(f func(*CBPeripheral, *CBService, *NSError, )) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.PeripheralDidDiscoverCharacteristicsForService = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) PeripheralDidUpdateValueForCharacteristicCallback(f func(*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)
}