my $expected_version = "2.2202";
print("import: Moose\n");
use Moose;

if (defined Moose->VERSION) {
	my $given_version = Moose->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose->VERSION . '
');

}
print("import: Moose::Exception::AccessorMustReadWrite\n");
use Moose::Exception::AccessorMustReadWrite;

if (defined Moose::Exception::AccessorMustReadWrite->VERSION) {
	my $given_version = Moose::Exception::AccessorMustReadWrite->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AccessorMustReadWrite->VERSION . '
');

}
print("import: Moose::Exception::AddParameterizableTypeTakesParameterizableType\n");
use Moose::Exception::AddParameterizableTypeTakesParameterizableType;

if (defined Moose::Exception::AddParameterizableTypeTakesParameterizableType->VERSION) {
	my $given_version = Moose::Exception::AddParameterizableTypeTakesParameterizableType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AddParameterizableTypeTakesParameterizableType->VERSION . '
');

}
print("import: Moose::Exception::AddRoleTakesAMooseMetaRoleInstance\n");
use Moose::Exception::AddRoleTakesAMooseMetaRoleInstance;

if (defined Moose::Exception::AddRoleTakesAMooseMetaRoleInstance->VERSION) {
	my $given_version = Moose::Exception::AddRoleTakesAMooseMetaRoleInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AddRoleTakesAMooseMetaRoleInstance->VERSION . '
');

}
print("import: Moose::Exception::AddRoleToARoleTakesAMooseMetaRole\n");
use Moose::Exception::AddRoleToARoleTakesAMooseMetaRole;

if (defined Moose::Exception::AddRoleToARoleTakesAMooseMetaRole->VERSION) {
	my $given_version = Moose::Exception::AddRoleToARoleTakesAMooseMetaRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AddRoleToARoleTakesAMooseMetaRole->VERSION . '
');

}
print("import: Moose::Exception::ApplyTakesABlessedInstance\n");
use Moose::Exception::ApplyTakesABlessedInstance;

if (defined Moose::Exception::ApplyTakesABlessedInstance->VERSION) {
	my $given_version = Moose::Exception::ApplyTakesABlessedInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ApplyTakesABlessedInstance->VERSION . '
');

}
print("import: Moose::Exception::AttachToClassNeedsAClassMOPClassInstanceOrASubclass\n");
use Moose::Exception::AttachToClassNeedsAClassMOPClassInstanceOrASubclass;

if (defined Moose::Exception::AttachToClassNeedsAClassMOPClassInstanceOrASubclass->VERSION) {
	my $given_version = Moose::Exception::AttachToClassNeedsAClassMOPClassInstanceOrASubclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttachToClassNeedsAClassMOPClassInstanceOrASubclass->VERSION . '
');

}
print("import: Moose::Exception::AttributeConflictInRoles\n");
use Moose::Exception::AttributeConflictInRoles;

if (defined Moose::Exception::AttributeConflictInRoles->VERSION) {
	my $given_version = Moose::Exception::AttributeConflictInRoles->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeConflictInRoles->VERSION . '
');

}
print("import: Moose::Exception::AttributeConflictInSummation\n");
use Moose::Exception::AttributeConflictInSummation;

if (defined Moose::Exception::AttributeConflictInSummation->VERSION) {
	my $given_version = Moose::Exception::AttributeConflictInSummation->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeConflictInSummation->VERSION . '
');

}
print("import: Moose::Exception::AttributeExtensionIsNotSupportedInRoles\n");
use Moose::Exception::AttributeExtensionIsNotSupportedInRoles;

if (defined Moose::Exception::AttributeExtensionIsNotSupportedInRoles->VERSION) {
	my $given_version = Moose::Exception::AttributeExtensionIsNotSupportedInRoles->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeExtensionIsNotSupportedInRoles->VERSION . '
');

}
print("import: Moose::Exception::AttributeIsRequired\n");
use Moose::Exception::AttributeIsRequired;

if (defined Moose::Exception::AttributeIsRequired->VERSION) {
	my $given_version = Moose::Exception::AttributeIsRequired->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeIsRequired->VERSION . '
');

}
print("import: Moose::Exception::AttributeMustBeAnClassMOPMixinAttributeCoreOrSubclass\n");
use Moose::Exception::AttributeMustBeAnClassMOPMixinAttributeCoreOrSubclass;

if (defined Moose::Exception::AttributeMustBeAnClassMOPMixinAttributeCoreOrSubclass->VERSION) {
	my $given_version = Moose::Exception::AttributeMustBeAnClassMOPMixinAttributeCoreOrSubclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeMustBeAnClassMOPMixinAttributeCoreOrSubclass->VERSION . '
');

}
print("import: Moose::Exception::AttributeNamesDoNotMatch\n");
use Moose::Exception::AttributeNamesDoNotMatch;

if (defined Moose::Exception::AttributeNamesDoNotMatch->VERSION) {
	my $given_version = Moose::Exception::AttributeNamesDoNotMatch->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeNamesDoNotMatch->VERSION . '
');

}
print("import: Moose::Exception::AttributeValueIsNotAnObject\n");
use Moose::Exception::AttributeValueIsNotAnObject;

if (defined Moose::Exception::AttributeValueIsNotAnObject->VERSION) {
	my $given_version = Moose::Exception::AttributeValueIsNotAnObject->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeValueIsNotAnObject->VERSION . '
');

}
print("import: Moose::Exception::AttributeValueIsNotDefined\n");
use Moose::Exception::AttributeValueIsNotDefined;

if (defined Moose::Exception::AttributeValueIsNotDefined->VERSION) {
	my $given_version = Moose::Exception::AttributeValueIsNotDefined->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AttributeValueIsNotDefined->VERSION . '
');

}
print("import: Moose::Exception::AutoDeRefNeedsArrayRefOrHashRef\n");
use Moose::Exception::AutoDeRefNeedsArrayRefOrHashRef;

if (defined Moose::Exception::AutoDeRefNeedsArrayRefOrHashRef->VERSION) {
	my $given_version = Moose::Exception::AutoDeRefNeedsArrayRefOrHashRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::AutoDeRefNeedsArrayRefOrHashRef->VERSION . '
');

}
print("import: Moose::Exception::BadOptionFormat\n");
use Moose::Exception::BadOptionFormat;

if (defined Moose::Exception::BadOptionFormat->VERSION) {
	my $given_version = Moose::Exception::BadOptionFormat->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::BadOptionFormat->VERSION . '
');

}
print("import: Moose::Exception::BothBuilderAndDefaultAreNotAllowed\n");
use Moose::Exception::BothBuilderAndDefaultAreNotAllowed;

if (defined Moose::Exception::BothBuilderAndDefaultAreNotAllowed->VERSION) {
	my $given_version = Moose::Exception::BothBuilderAndDefaultAreNotAllowed->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::BothBuilderAndDefaultAreNotAllowed->VERSION . '
');

}
print("import: Moose::Exception::BuilderDoesNotExist\n");
use Moose::Exception::BuilderDoesNotExist;

if (defined Moose::Exception::BuilderDoesNotExist->VERSION) {
	my $given_version = Moose::Exception::BuilderDoesNotExist->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::BuilderDoesNotExist->VERSION . '
');

}
print("import: Moose::Exception::BuilderMethodNotSupportedForAttribute\n");
use Moose::Exception::BuilderMethodNotSupportedForAttribute;

if (defined Moose::Exception::BuilderMethodNotSupportedForAttribute->VERSION) {
	my $given_version = Moose::Exception::BuilderMethodNotSupportedForAttribute->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::BuilderMethodNotSupportedForAttribute->VERSION . '
');

}
print("import: Moose::Exception::BuilderMethodNotSupportedForInlineAttribute\n");
use Moose::Exception::BuilderMethodNotSupportedForInlineAttribute;

if (defined Moose::Exception::BuilderMethodNotSupportedForInlineAttribute->VERSION) {
	my $given_version = Moose::Exception::BuilderMethodNotSupportedForInlineAttribute->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::BuilderMethodNotSupportedForInlineAttribute->VERSION . '
');

}
print("import: Moose::Exception::BuilderMustBeAMethodName\n");
use Moose::Exception::BuilderMustBeAMethodName;

if (defined Moose::Exception::BuilderMustBeAMethodName->VERSION) {
	my $given_version = Moose::Exception::BuilderMustBeAMethodName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::BuilderMustBeAMethodName->VERSION . '
');

}
print("import: Moose::Exception::CallingMethodOnAnImmutableInstance\n");
use Moose::Exception::CallingMethodOnAnImmutableInstance;

if (defined Moose::Exception::CallingMethodOnAnImmutableInstance->VERSION) {
	my $given_version = Moose::Exception::CallingMethodOnAnImmutableInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CallingMethodOnAnImmutableInstance->VERSION . '
');

}
print("import: Moose::Exception::CallingReadOnlyMethodOnAnImmutableInstance\n");
use Moose::Exception::CallingReadOnlyMethodOnAnImmutableInstance;

if (defined Moose::Exception::CallingReadOnlyMethodOnAnImmutableInstance->VERSION) {
	my $given_version = Moose::Exception::CallingReadOnlyMethodOnAnImmutableInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CallingReadOnlyMethodOnAnImmutableInstance->VERSION . '
');

}
print("import: Moose::Exception::CanExtendOnlyClasses\n");
use Moose::Exception::CanExtendOnlyClasses;

if (defined Moose::Exception::CanExtendOnlyClasses->VERSION) {
	my $given_version = Moose::Exception::CanExtendOnlyClasses->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CanExtendOnlyClasses->VERSION . '
');

}
print("import: Moose::Exception::CanOnlyConsumeRole\n");
use Moose::Exception::CanOnlyConsumeRole;

if (defined Moose::Exception::CanOnlyConsumeRole->VERSION) {
	my $given_version = Moose::Exception::CanOnlyConsumeRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CanOnlyConsumeRole->VERSION . '
');

}
print("import: Moose::Exception::CanOnlyWrapBlessedCode\n");
use Moose::Exception::CanOnlyWrapBlessedCode;

if (defined Moose::Exception::CanOnlyWrapBlessedCode->VERSION) {
	my $given_version = Moose::Exception::CanOnlyWrapBlessedCode->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CanOnlyWrapBlessedCode->VERSION . '
');

}
print("import: Moose::Exception::CanReblessOnlyIntoASubclass\n");
use Moose::Exception::CanReblessOnlyIntoASubclass;

if (defined Moose::Exception::CanReblessOnlyIntoASubclass->VERSION) {
	my $given_version = Moose::Exception::CanReblessOnlyIntoASubclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CanReblessOnlyIntoASubclass->VERSION . '
');

}
print("import: Moose::Exception::CanReblessOnlyIntoASuperclass\n");
use Moose::Exception::CanReblessOnlyIntoASuperclass;

if (defined Moose::Exception::CanReblessOnlyIntoASuperclass->VERSION) {
	my $given_version = Moose::Exception::CanReblessOnlyIntoASuperclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CanReblessOnlyIntoASuperclass->VERSION . '
');

}
print("import: Moose::Exception::CannotAddAdditionalTypeCoercionsToUnion\n");
use Moose::Exception::CannotAddAdditionalTypeCoercionsToUnion;

if (defined Moose::Exception::CannotAddAdditionalTypeCoercionsToUnion->VERSION) {
	my $given_version = Moose::Exception::CannotAddAdditionalTypeCoercionsToUnion->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotAddAdditionalTypeCoercionsToUnion->VERSION . '
');

}
print("import: Moose::Exception::CannotAddAsAnAttributeToARole\n");
use Moose::Exception::CannotAddAsAnAttributeToARole;

if (defined Moose::Exception::CannotAddAsAnAttributeToARole->VERSION) {
	my $given_version = Moose::Exception::CannotAddAsAnAttributeToARole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotAddAsAnAttributeToARole->VERSION . '
');

}
print("import: Moose::Exception::CannotApplyBaseClassRolesToRole\n");
use Moose::Exception::CannotApplyBaseClassRolesToRole;

if (defined Moose::Exception::CannotApplyBaseClassRolesToRole->VERSION) {
	my $given_version = Moose::Exception::CannotApplyBaseClassRolesToRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotApplyBaseClassRolesToRole->VERSION . '
');

}
print("import: Moose::Exception::CannotAssignValueToReadOnlyAccessor\n");
use Moose::Exception::CannotAssignValueToReadOnlyAccessor;

if (defined Moose::Exception::CannotAssignValueToReadOnlyAccessor->VERSION) {
	my $given_version = Moose::Exception::CannotAssignValueToReadOnlyAccessor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotAssignValueToReadOnlyAccessor->VERSION . '
');

}
print("import: Moose::Exception::CannotAugmentIfLocalMethodPresent\n");
use Moose::Exception::CannotAugmentIfLocalMethodPresent;

if (defined Moose::Exception::CannotAugmentIfLocalMethodPresent->VERSION) {
	my $given_version = Moose::Exception::CannotAugmentIfLocalMethodPresent->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotAugmentIfLocalMethodPresent->VERSION . '
');

}
print("import: Moose::Exception::CannotAugmentNoSuperMethod\n");
use Moose::Exception::CannotAugmentNoSuperMethod;

if (defined Moose::Exception::CannotAugmentNoSuperMethod->VERSION) {
	my $given_version = Moose::Exception::CannotAugmentNoSuperMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotAugmentNoSuperMethod->VERSION . '
');

}
print("import: Moose::Exception::CannotAutoDerefWithoutIsa\n");
use Moose::Exception::CannotAutoDerefWithoutIsa;

if (defined Moose::Exception::CannotAutoDerefWithoutIsa->VERSION) {
	my $given_version = Moose::Exception::CannotAutoDerefWithoutIsa->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotAutoDerefWithoutIsa->VERSION . '
');

}
print("import: Moose::Exception::CannotAutoDereferenceTypeConstraint\n");
use Moose::Exception::CannotAutoDereferenceTypeConstraint;

if (defined Moose::Exception::CannotAutoDereferenceTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::CannotAutoDereferenceTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotAutoDereferenceTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::CannotCalculateNativeType\n");
use Moose::Exception::CannotCalculateNativeType;

if (defined Moose::Exception::CannotCalculateNativeType->VERSION) {
	my $given_version = Moose::Exception::CannotCalculateNativeType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCalculateNativeType->VERSION . '
');

}
print("import: Moose::Exception::CannotCallAnAbstractBaseMethod\n");
use Moose::Exception::CannotCallAnAbstractBaseMethod;

if (defined Moose::Exception::CannotCallAnAbstractBaseMethod->VERSION) {
	my $given_version = Moose::Exception::CannotCallAnAbstractBaseMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCallAnAbstractBaseMethod->VERSION . '
');

}
print("import: Moose::Exception::CannotCallAnAbstractMethod\n");
use Moose::Exception::CannotCallAnAbstractMethod;

if (defined Moose::Exception::CannotCallAnAbstractMethod->VERSION) {
	my $given_version = Moose::Exception::CannotCallAnAbstractMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCallAnAbstractMethod->VERSION . '
');

}
print("import: Moose::Exception::CannotCoerceAWeakRef\n");
use Moose::Exception::CannotCoerceAWeakRef;

if (defined Moose::Exception::CannotCoerceAWeakRef->VERSION) {
	my $given_version = Moose::Exception::CannotCoerceAWeakRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCoerceAWeakRef->VERSION . '
');

}
print("import: Moose::Exception::CannotCoerceAttributeWhichHasNoCoercion\n");
use Moose::Exception::CannotCoerceAttributeWhichHasNoCoercion;

if (defined Moose::Exception::CannotCoerceAttributeWhichHasNoCoercion->VERSION) {
	my $given_version = Moose::Exception::CannotCoerceAttributeWhichHasNoCoercion->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCoerceAttributeWhichHasNoCoercion->VERSION . '
');

}
print("import: Moose::Exception::CannotCreateHigherOrderTypeWithoutATypeParameter\n");
use Moose::Exception::CannotCreateHigherOrderTypeWithoutATypeParameter;

if (defined Moose::Exception::CannotCreateHigherOrderTypeWithoutATypeParameter->VERSION) {
	my $given_version = Moose::Exception::CannotCreateHigherOrderTypeWithoutATypeParameter->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCreateHigherOrderTypeWithoutATypeParameter->VERSION . '
');

}
print("import: Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresent\n");
use Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresent;

if (defined Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresent->VERSION) {
	my $given_version = Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresent->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresent->VERSION . '
');

}
print("import: Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresentInClass\n");
use Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresentInClass;

if (defined Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresentInClass->VERSION) {
	my $given_version = Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresentInClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotCreateMethodAliasLocalMethodIsPresentInClass->VERSION . '
');

}
print("import: Moose::Exception::CannotDelegateLocalMethodIsPresent\n");
use Moose::Exception::CannotDelegateLocalMethodIsPresent;

if (defined Moose::Exception::CannotDelegateLocalMethodIsPresent->VERSION) {
	my $given_version = Moose::Exception::CannotDelegateLocalMethodIsPresent->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotDelegateLocalMethodIsPresent->VERSION . '
');

}
print("import: Moose::Exception::CannotDelegateWithoutIsa\n");
use Moose::Exception::CannotDelegateWithoutIsa;

if (defined Moose::Exception::CannotDelegateWithoutIsa->VERSION) {
	my $given_version = Moose::Exception::CannotDelegateWithoutIsa->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotDelegateWithoutIsa->VERSION . '
');

}
print("import: Moose::Exception::CannotFindDelegateMetaclass\n");
use Moose::Exception::CannotFindDelegateMetaclass;

if (defined Moose::Exception::CannotFindDelegateMetaclass->VERSION) {
	my $given_version = Moose::Exception::CannotFindDelegateMetaclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotFindDelegateMetaclass->VERSION . '
');

}
print("import: Moose::Exception::CannotFindType\n");
use Moose::Exception::CannotFindType;

if (defined Moose::Exception::CannotFindType->VERSION) {
	my $given_version = Moose::Exception::CannotFindType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotFindType->VERSION . '
');

}
print("import: Moose::Exception::CannotFindTypeGivenToMatchOnType\n");
use Moose::Exception::CannotFindTypeGivenToMatchOnType;

if (defined Moose::Exception::CannotFindTypeGivenToMatchOnType->VERSION) {
	my $given_version = Moose::Exception::CannotFindTypeGivenToMatchOnType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotFindTypeGivenToMatchOnType->VERSION . '
');

}
print("import: Moose::Exception::CannotFixMetaclassCompatibility\n");
use Moose::Exception::CannotFixMetaclassCompatibility;

if (defined Moose::Exception::CannotFixMetaclassCompatibility->VERSION) {
	my $given_version = Moose::Exception::CannotFixMetaclassCompatibility->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotFixMetaclassCompatibility->VERSION . '
');

}
print("import: Moose::Exception::CannotGenerateInlineConstraint\n");
use Moose::Exception::CannotGenerateInlineConstraint;

if (defined Moose::Exception::CannotGenerateInlineConstraint->VERSION) {
	my $given_version = Moose::Exception::CannotGenerateInlineConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotGenerateInlineConstraint->VERSION . '
');

}
print("import: Moose::Exception::CannotInitializeMooseMetaRoleComposite\n");
use Moose::Exception::CannotInitializeMooseMetaRoleComposite;

if (defined Moose::Exception::CannotInitializeMooseMetaRoleComposite->VERSION) {
	my $given_version = Moose::Exception::CannotInitializeMooseMetaRoleComposite->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotInitializeMooseMetaRoleComposite->VERSION . '
');

}
print("import: Moose::Exception::CannotInlineTypeConstraintCheck\n");
use Moose::Exception::CannotInlineTypeConstraintCheck;

if (defined Moose::Exception::CannotInlineTypeConstraintCheck->VERSION) {
	my $given_version = Moose::Exception::CannotInlineTypeConstraintCheck->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotInlineTypeConstraintCheck->VERSION . '
');

}
print("import: Moose::Exception::CannotLocatePackageInINC\n");
use Moose::Exception::CannotLocatePackageInINC;

if (defined Moose::Exception::CannotLocatePackageInINC->VERSION) {
	my $given_version = Moose::Exception::CannotLocatePackageInINC->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotLocatePackageInINC->VERSION . '
');

}
print("import: Moose::Exception::CannotMakeMetaclassCompatible\n");
use Moose::Exception::CannotMakeMetaclassCompatible;

if (defined Moose::Exception::CannotMakeMetaclassCompatible->VERSION) {
	my $given_version = Moose::Exception::CannotMakeMetaclassCompatible->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotMakeMetaclassCompatible->VERSION . '
');

}
print("import: Moose::Exception::CannotOverrideALocalMethod\n");
use Moose::Exception::CannotOverrideALocalMethod;

if (defined Moose::Exception::CannotOverrideALocalMethod->VERSION) {
	my $given_version = Moose::Exception::CannotOverrideALocalMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotOverrideALocalMethod->VERSION . '
');

}
print("import: Moose::Exception::CannotOverrideBodyOfMetaMethods\n");
use Moose::Exception::CannotOverrideBodyOfMetaMethods;

if (defined Moose::Exception::CannotOverrideBodyOfMetaMethods->VERSION) {
	my $given_version = Moose::Exception::CannotOverrideBodyOfMetaMethods->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotOverrideBodyOfMetaMethods->VERSION . '
');

}
print("import: Moose::Exception::CannotOverrideLocalMethodIsPresent\n");
use Moose::Exception::CannotOverrideLocalMethodIsPresent;

if (defined Moose::Exception::CannotOverrideLocalMethodIsPresent->VERSION) {
	my $given_version = Moose::Exception::CannotOverrideLocalMethodIsPresent->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotOverrideLocalMethodIsPresent->VERSION . '
');

}
print("import: Moose::Exception::CannotOverrideNoSuperMethod\n");
use Moose::Exception::CannotOverrideNoSuperMethod;

if (defined Moose::Exception::CannotOverrideNoSuperMethod->VERSION) {
	my $given_version = Moose::Exception::CannotOverrideNoSuperMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotOverrideNoSuperMethod->VERSION . '
');

}
print("import: Moose::Exception::CannotRegisterUnnamedTypeConstraint\n");
use Moose::Exception::CannotRegisterUnnamedTypeConstraint;

if (defined Moose::Exception::CannotRegisterUnnamedTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::CannotRegisterUnnamedTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotRegisterUnnamedTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::CannotUseLazyBuildAndDefaultSimultaneously\n");
use Moose::Exception::CannotUseLazyBuildAndDefaultSimultaneously;

if (defined Moose::Exception::CannotUseLazyBuildAndDefaultSimultaneously->VERSION) {
	my $given_version = Moose::Exception::CannotUseLazyBuildAndDefaultSimultaneously->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CannotUseLazyBuildAndDefaultSimultaneously->VERSION . '
');

}
print("import: Moose::Exception::CircularReferenceInAlso\n");
use Moose::Exception::CircularReferenceInAlso;

if (defined Moose::Exception::CircularReferenceInAlso->VERSION) {
	my $given_version = Moose::Exception::CircularReferenceInAlso->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CircularReferenceInAlso->VERSION . '
');

}
print("import: Moose::Exception::ClassDoesNotHaveInitMeta\n");
use Moose::Exception::ClassDoesNotHaveInitMeta;

if (defined Moose::Exception::ClassDoesNotHaveInitMeta->VERSION) {
	my $given_version = Moose::Exception::ClassDoesNotHaveInitMeta->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ClassDoesNotHaveInitMeta->VERSION . '
');

}
print("import: Moose::Exception::ClassDoesTheExcludedRole\n");
use Moose::Exception::ClassDoesTheExcludedRole;

if (defined Moose::Exception::ClassDoesTheExcludedRole->VERSION) {
	my $given_version = Moose::Exception::ClassDoesTheExcludedRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ClassDoesTheExcludedRole->VERSION . '
');

}
print("import: Moose::Exception::ClassNamesDoNotMatch\n");
use Moose::Exception::ClassNamesDoNotMatch;

if (defined Moose::Exception::ClassNamesDoNotMatch->VERSION) {
	my $given_version = Moose::Exception::ClassNamesDoNotMatch->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ClassNamesDoNotMatch->VERSION . '
');

}
print("import: Moose::Exception::CloneObjectExpectsAnInstanceOfMetaclass\n");
use Moose::Exception::CloneObjectExpectsAnInstanceOfMetaclass;

if (defined Moose::Exception::CloneObjectExpectsAnInstanceOfMetaclass->VERSION) {
	my $given_version = Moose::Exception::CloneObjectExpectsAnInstanceOfMetaclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CloneObjectExpectsAnInstanceOfMetaclass->VERSION . '
');

}
print("import: Moose::Exception::CodeBlockMustBeACodeRef\n");
use Moose::Exception::CodeBlockMustBeACodeRef;

if (defined Moose::Exception::CodeBlockMustBeACodeRef->VERSION) {
	my $given_version = Moose::Exception::CodeBlockMustBeACodeRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CodeBlockMustBeACodeRef->VERSION . '
');

}
print("import: Moose::Exception::CoercingWithoutCoercions\n");
use Moose::Exception::CoercingWithoutCoercions;

if (defined Moose::Exception::CoercingWithoutCoercions->VERSION) {
	my $given_version = Moose::Exception::CoercingWithoutCoercions->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CoercingWithoutCoercions->VERSION . '
');

}
print("import: Moose::Exception::CoercionAlreadyExists\n");
use Moose::Exception::CoercionAlreadyExists;

if (defined Moose::Exception::CoercionAlreadyExists->VERSION) {
	my $given_version = Moose::Exception::CoercionAlreadyExists->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CoercionAlreadyExists->VERSION . '
');

}
print("import: Moose::Exception::CoercionNeedsTypeConstraint\n");
use Moose::Exception::CoercionNeedsTypeConstraint;

if (defined Moose::Exception::CoercionNeedsTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::CoercionNeedsTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CoercionNeedsTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::ConflictDetectedInCheckRoleExclusions\n");
use Moose::Exception::ConflictDetectedInCheckRoleExclusions;

if (defined Moose::Exception::ConflictDetectedInCheckRoleExclusions->VERSION) {
	my $given_version = Moose::Exception::ConflictDetectedInCheckRoleExclusions->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ConflictDetectedInCheckRoleExclusions->VERSION . '
');

}
print("import: Moose::Exception::ConflictDetectedInCheckRoleExclusionsInToClass\n");
use Moose::Exception::ConflictDetectedInCheckRoleExclusionsInToClass;

if (defined Moose::Exception::ConflictDetectedInCheckRoleExclusionsInToClass->VERSION) {
	my $given_version = Moose::Exception::ConflictDetectedInCheckRoleExclusionsInToClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ConflictDetectedInCheckRoleExclusionsInToClass->VERSION . '
');

}
print("import: Moose::Exception::ConstructClassInstanceTakesPackageName\n");
use Moose::Exception::ConstructClassInstanceTakesPackageName;

if (defined Moose::Exception::ConstructClassInstanceTakesPackageName->VERSION) {
	my $given_version = Moose::Exception::ConstructClassInstanceTakesPackageName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ConstructClassInstanceTakesPackageName->VERSION . '
');

}
print("import: Moose::Exception::CouldNotCreateMethod\n");
use Moose::Exception::CouldNotCreateMethod;

if (defined Moose::Exception::CouldNotCreateMethod->VERSION) {
	my $given_version = Moose::Exception::CouldNotCreateMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotCreateMethod->VERSION . '
');

}
print("import: Moose::Exception::CouldNotCreateWriter\n");
use Moose::Exception::CouldNotCreateWriter;

if (defined Moose::Exception::CouldNotCreateWriter->VERSION) {
	my $given_version = Moose::Exception::CouldNotCreateWriter->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotCreateWriter->VERSION . '
');

}
print("import: Moose::Exception::CouldNotEvalConstructor\n");
use Moose::Exception::CouldNotEvalConstructor;

if (defined Moose::Exception::CouldNotEvalConstructor->VERSION) {
	my $given_version = Moose::Exception::CouldNotEvalConstructor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotEvalConstructor->VERSION . '
');

}
print("import: Moose::Exception::CouldNotEvalDestructor\n");
use Moose::Exception::CouldNotEvalDestructor;

if (defined Moose::Exception::CouldNotEvalDestructor->VERSION) {
	my $given_version = Moose::Exception::CouldNotEvalDestructor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotEvalDestructor->VERSION . '
');

}
print("import: Moose::Exception::CouldNotFindTypeConstraintToCoerceFrom\n");
use Moose::Exception::CouldNotFindTypeConstraintToCoerceFrom;

if (defined Moose::Exception::CouldNotFindTypeConstraintToCoerceFrom->VERSION) {
	my $given_version = Moose::Exception::CouldNotFindTypeConstraintToCoerceFrom->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotFindTypeConstraintToCoerceFrom->VERSION . '
');

}
print("import: Moose::Exception::CouldNotGenerateInlineAttributeMethod\n");
use Moose::Exception::CouldNotGenerateInlineAttributeMethod;

if (defined Moose::Exception::CouldNotGenerateInlineAttributeMethod->VERSION) {
	my $given_version = Moose::Exception::CouldNotGenerateInlineAttributeMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotGenerateInlineAttributeMethod->VERSION . '
');

}
print("import: Moose::Exception::CouldNotLocateTypeConstraintForUnion\n");
use Moose::Exception::CouldNotLocateTypeConstraintForUnion;

if (defined Moose::Exception::CouldNotLocateTypeConstraintForUnion->VERSION) {
	my $given_version = Moose::Exception::CouldNotLocateTypeConstraintForUnion->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotLocateTypeConstraintForUnion->VERSION . '
');

}
print("import: Moose::Exception::CouldNotParseType\n");
use Moose::Exception::CouldNotParseType;

if (defined Moose::Exception::CouldNotParseType->VERSION) {
	my $given_version = Moose::Exception::CouldNotParseType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CouldNotParseType->VERSION . '
');

}
print("import: Moose::Exception::CreateMOPClassTakesArrayRefOfAttributes\n");
use Moose::Exception::CreateMOPClassTakesArrayRefOfAttributes;

if (defined Moose::Exception::CreateMOPClassTakesArrayRefOfAttributes->VERSION) {
	my $given_version = Moose::Exception::CreateMOPClassTakesArrayRefOfAttributes->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CreateMOPClassTakesArrayRefOfAttributes->VERSION . '
');

}
print("import: Moose::Exception::CreateMOPClassTakesArrayRefOfSuperclasses\n");
use Moose::Exception::CreateMOPClassTakesArrayRefOfSuperclasses;

if (defined Moose::Exception::CreateMOPClassTakesArrayRefOfSuperclasses->VERSION) {
	my $given_version = Moose::Exception::CreateMOPClassTakesArrayRefOfSuperclasses->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CreateMOPClassTakesArrayRefOfSuperclasses->VERSION . '
');

}
print("import: Moose::Exception::CreateMOPClassTakesHashRefOfMethods\n");
use Moose::Exception::CreateMOPClassTakesHashRefOfMethods;

if (defined Moose::Exception::CreateMOPClassTakesHashRefOfMethods->VERSION) {
	my $given_version = Moose::Exception::CreateMOPClassTakesHashRefOfMethods->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CreateMOPClassTakesHashRefOfMethods->VERSION . '
');

}
print("import: Moose::Exception::CreateTakesArrayRefOfRoles\n");
use Moose::Exception::CreateTakesArrayRefOfRoles;

if (defined Moose::Exception::CreateTakesArrayRefOfRoles->VERSION) {
	my $given_version = Moose::Exception::CreateTakesArrayRefOfRoles->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CreateTakesArrayRefOfRoles->VERSION . '
');

}
print("import: Moose::Exception::CreateTakesHashRefOfAttributes\n");
use Moose::Exception::CreateTakesHashRefOfAttributes;

if (defined Moose::Exception::CreateTakesHashRefOfAttributes->VERSION) {
	my $given_version = Moose::Exception::CreateTakesHashRefOfAttributes->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CreateTakesHashRefOfAttributes->VERSION . '
');

}
print("import: Moose::Exception::CreateTakesHashRefOfMethods\n");
use Moose::Exception::CreateTakesHashRefOfMethods;

if (defined Moose::Exception::CreateTakesHashRefOfMethods->VERSION) {
	my $given_version = Moose::Exception::CreateTakesHashRefOfMethods->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::CreateTakesHashRefOfMethods->VERSION . '
');

}
print("import: Moose::Exception::DefaultToMatchOnTypeMustBeCodeRef\n");
use Moose::Exception::DefaultToMatchOnTypeMustBeCodeRef;

if (defined Moose::Exception::DefaultToMatchOnTypeMustBeCodeRef->VERSION) {
	my $given_version = Moose::Exception::DefaultToMatchOnTypeMustBeCodeRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::DefaultToMatchOnTypeMustBeCodeRef->VERSION . '
');

}
print("import: Moose::Exception::DelegationToAClassWhichIsNotLoaded\n");
use Moose::Exception::DelegationToAClassWhichIsNotLoaded;

if (defined Moose::Exception::DelegationToAClassWhichIsNotLoaded->VERSION) {
	my $given_version = Moose::Exception::DelegationToAClassWhichIsNotLoaded->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::DelegationToAClassWhichIsNotLoaded->VERSION . '
');

}
print("import: Moose::Exception::DelegationToARoleWhichIsNotLoaded\n");
use Moose::Exception::DelegationToARoleWhichIsNotLoaded;

if (defined Moose::Exception::DelegationToARoleWhichIsNotLoaded->VERSION) {
	my $given_version = Moose::Exception::DelegationToARoleWhichIsNotLoaded->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::DelegationToARoleWhichIsNotLoaded->VERSION . '
');

}
print("import: Moose::Exception::DelegationToATypeWhichIsNotAClass\n");
use Moose::Exception::DelegationToATypeWhichIsNotAClass;

if (defined Moose::Exception::DelegationToATypeWhichIsNotAClass->VERSION) {
	my $given_version = Moose::Exception::DelegationToATypeWhichIsNotAClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::DelegationToATypeWhichIsNotAClass->VERSION . '
');

}
print("import: Moose::Exception::DoesRequiresRoleName\n");
use Moose::Exception::DoesRequiresRoleName;

if (defined Moose::Exception::DoesRequiresRoleName->VERSION) {
	my $given_version = Moose::Exception::DoesRequiresRoleName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::DoesRequiresRoleName->VERSION . '
');

}
print("import: Moose::Exception::EnumCalledWithAnArrayRefAndAdditionalArgs\n");
use Moose::Exception::EnumCalledWithAnArrayRefAndAdditionalArgs;

if (defined Moose::Exception::EnumCalledWithAnArrayRefAndAdditionalArgs->VERSION) {
	my $given_version = Moose::Exception::EnumCalledWithAnArrayRefAndAdditionalArgs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::EnumCalledWithAnArrayRefAndAdditionalArgs->VERSION . '
');

}
print("import: Moose::Exception::EnumValuesMustBeString\n");
use Moose::Exception::EnumValuesMustBeString;

if (defined Moose::Exception::EnumValuesMustBeString->VERSION) {
	my $given_version = Moose::Exception::EnumValuesMustBeString->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::EnumValuesMustBeString->VERSION . '
');

}
print("import: Moose::Exception::ExtendsMissingArgs\n");
use Moose::Exception::ExtendsMissingArgs;

if (defined Moose::Exception::ExtendsMissingArgs->VERSION) {
	my $given_version = Moose::Exception::ExtendsMissingArgs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ExtendsMissingArgs->VERSION . '
');

}
print("import: Moose::Exception::HandlesMustBeAHashRef\n");
use Moose::Exception::HandlesMustBeAHashRef;

if (defined Moose::Exception::HandlesMustBeAHashRef->VERSION) {
	my $given_version = Moose::Exception::HandlesMustBeAHashRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::HandlesMustBeAHashRef->VERSION . '
');

}
print("import: Moose::Exception::IllegalInheritedOptions\n");
use Moose::Exception::IllegalInheritedOptions;

if (defined Moose::Exception::IllegalInheritedOptions->VERSION) {
	my $given_version = Moose::Exception::IllegalInheritedOptions->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::IllegalInheritedOptions->VERSION . '
');

}
print("import: Moose::Exception::IllegalMethodTypeToAddMethodModifier\n");
use Moose::Exception::IllegalMethodTypeToAddMethodModifier;

if (defined Moose::Exception::IllegalMethodTypeToAddMethodModifier->VERSION) {
	my $given_version = Moose::Exception::IllegalMethodTypeToAddMethodModifier->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::IllegalMethodTypeToAddMethodModifier->VERSION . '
');

}
print("import: Moose::Exception::IncompatibleMetaclassOfSuperclass\n");
use Moose::Exception::IncompatibleMetaclassOfSuperclass;

if (defined Moose::Exception::IncompatibleMetaclassOfSuperclass->VERSION) {
	my $given_version = Moose::Exception::IncompatibleMetaclassOfSuperclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::IncompatibleMetaclassOfSuperclass->VERSION . '
');

}
print("import: Moose::Exception::InitMetaRequiresClass\n");
use Moose::Exception::InitMetaRequiresClass;

if (defined Moose::Exception::InitMetaRequiresClass->VERSION) {
	my $given_version = Moose::Exception::InitMetaRequiresClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InitMetaRequiresClass->VERSION . '
');

}
print("import: Moose::Exception::InitializeTakesUnBlessedPackageName\n");
use Moose::Exception::InitializeTakesUnBlessedPackageName;

if (defined Moose::Exception::InitializeTakesUnBlessedPackageName->VERSION) {
	my $given_version = Moose::Exception::InitializeTakesUnBlessedPackageName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InitializeTakesUnBlessedPackageName->VERSION . '
');

}
print("import: Moose::Exception::InstanceBlessedIntoWrongClass\n");
use Moose::Exception::InstanceBlessedIntoWrongClass;

if (defined Moose::Exception::InstanceBlessedIntoWrongClass->VERSION) {
	my $given_version = Moose::Exception::InstanceBlessedIntoWrongClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InstanceBlessedIntoWrongClass->VERSION . '
');

}
print("import: Moose::Exception::InstanceMustBeABlessedReference\n");
use Moose::Exception::InstanceMustBeABlessedReference;

if (defined Moose::Exception::InstanceMustBeABlessedReference->VERSION) {
	my $given_version = Moose::Exception::InstanceMustBeABlessedReference->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InstanceMustBeABlessedReference->VERSION . '
');

}
print("import: Moose::Exception::InvalidArgPassedToMooseUtilMetaRole\n");
use Moose::Exception::InvalidArgPassedToMooseUtilMetaRole;

if (defined Moose::Exception::InvalidArgPassedToMooseUtilMetaRole->VERSION) {
	my $given_version = Moose::Exception::InvalidArgPassedToMooseUtilMetaRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidArgPassedToMooseUtilMetaRole->VERSION . '
');

}
print("import: Moose::Exception::InvalidArgumentToMethod\n");
use Moose::Exception::InvalidArgumentToMethod;

if (defined Moose::Exception::InvalidArgumentToMethod->VERSION) {
	my $given_version = Moose::Exception::InvalidArgumentToMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidArgumentToMethod->VERSION . '
');

}
print("import: Moose::Exception::InvalidArgumentsToTraitAliases\n");
use Moose::Exception::InvalidArgumentsToTraitAliases;

if (defined Moose::Exception::InvalidArgumentsToTraitAliases->VERSION) {
	my $given_version = Moose::Exception::InvalidArgumentsToTraitAliases->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidArgumentsToTraitAliases->VERSION . '
');

}
print("import: Moose::Exception::InvalidBaseTypeGivenToCreateParameterizedTypeConstraint\n");
use Moose::Exception::InvalidBaseTypeGivenToCreateParameterizedTypeConstraint;

if (defined Moose::Exception::InvalidBaseTypeGivenToCreateParameterizedTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::InvalidBaseTypeGivenToCreateParameterizedTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidBaseTypeGivenToCreateParameterizedTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::InvalidHandleValue\n");
use Moose::Exception::InvalidHandleValue;

if (defined Moose::Exception::InvalidHandleValue->VERSION) {
	my $given_version = Moose::Exception::InvalidHandleValue->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidHandleValue->VERSION . '
');

}
print("import: Moose::Exception::InvalidHasProvidedInARole\n");
use Moose::Exception::InvalidHasProvidedInARole;

if (defined Moose::Exception::InvalidHasProvidedInARole->VERSION) {
	my $given_version = Moose::Exception::InvalidHasProvidedInARole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidHasProvidedInARole->VERSION . '
');

}
print("import: Moose::Exception::InvalidNameForType\n");
use Moose::Exception::InvalidNameForType;

if (defined Moose::Exception::InvalidNameForType->VERSION) {
	my $given_version = Moose::Exception::InvalidNameForType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidNameForType->VERSION . '
');

}
print("import: Moose::Exception::InvalidOverloadOperator\n");
use Moose::Exception::InvalidOverloadOperator;

if (defined Moose::Exception::InvalidOverloadOperator->VERSION) {
	my $given_version = Moose::Exception::InvalidOverloadOperator->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidOverloadOperator->VERSION . '
');

}
print("import: Moose::Exception::InvalidRoleApplication\n");
use Moose::Exception::InvalidRoleApplication;

if (defined Moose::Exception::InvalidRoleApplication->VERSION) {
	my $given_version = Moose::Exception::InvalidRoleApplication->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidRoleApplication->VERSION . '
');

}
print("import: Moose::Exception::InvalidTypeConstraint\n");
use Moose::Exception::InvalidTypeConstraint;

if (defined Moose::Exception::InvalidTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::InvalidTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::InvalidTypeGivenToCreateParameterizedTypeConstraint\n");
use Moose::Exception::InvalidTypeGivenToCreateParameterizedTypeConstraint;

if (defined Moose::Exception::InvalidTypeGivenToCreateParameterizedTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::InvalidTypeGivenToCreateParameterizedTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidTypeGivenToCreateParameterizedTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::InvalidValueForIs\n");
use Moose::Exception::InvalidValueForIs;

if (defined Moose::Exception::InvalidValueForIs->VERSION) {
	my $given_version = Moose::Exception::InvalidValueForIs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::InvalidValueForIs->VERSION . '
');

}
print("import: Moose::Exception::IsaDoesNotDoTheRole\n");
use Moose::Exception::IsaDoesNotDoTheRole;

if (defined Moose::Exception::IsaDoesNotDoTheRole->VERSION) {
	my $given_version = Moose::Exception::IsaDoesNotDoTheRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::IsaDoesNotDoTheRole->VERSION . '
');

}
print("import: Moose::Exception::IsaLacksDoesMethod\n");
use Moose::Exception::IsaLacksDoesMethod;

if (defined Moose::Exception::IsaLacksDoesMethod->VERSION) {
	my $given_version = Moose::Exception::IsaLacksDoesMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::IsaLacksDoesMethod->VERSION . '
');

}
print("import: Moose::Exception::LazyAttributeNeedsADefault\n");
use Moose::Exception::LazyAttributeNeedsADefault;

if (defined Moose::Exception::LazyAttributeNeedsADefault->VERSION) {
	my $given_version = Moose::Exception::LazyAttributeNeedsADefault->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::LazyAttributeNeedsADefault->VERSION . '
');

}
print("import: Moose::Exception::Legacy\n");
use Moose::Exception::Legacy;

if (defined Moose::Exception::Legacy->VERSION) {
	my $given_version = Moose::Exception::Legacy->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Legacy->VERSION . '
');

}
print("import: Moose::Exception::MOPAttributeNewNeedsAttributeName\n");
use Moose::Exception::MOPAttributeNewNeedsAttributeName;

if (defined Moose::Exception::MOPAttributeNewNeedsAttributeName->VERSION) {
	my $given_version = Moose::Exception::MOPAttributeNewNeedsAttributeName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MOPAttributeNewNeedsAttributeName->VERSION . '
');

}
print("import: Moose::Exception::MatchActionMustBeACodeRef\n");
use Moose::Exception::MatchActionMustBeACodeRef;

if (defined Moose::Exception::MatchActionMustBeACodeRef->VERSION) {
	my $given_version = Moose::Exception::MatchActionMustBeACodeRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MatchActionMustBeACodeRef->VERSION . '
');

}
print("import: Moose::Exception::MessageParameterMustBeCodeRef\n");
use Moose::Exception::MessageParameterMustBeCodeRef;

if (defined Moose::Exception::MessageParameterMustBeCodeRef->VERSION) {
	my $given_version = Moose::Exception::MessageParameterMustBeCodeRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MessageParameterMustBeCodeRef->VERSION . '
');

}
print("import: Moose::Exception::MetaclassIsAClassNotASubclassOfGivenMetaclass\n");
use Moose::Exception::MetaclassIsAClassNotASubclassOfGivenMetaclass;

if (defined Moose::Exception::MetaclassIsAClassNotASubclassOfGivenMetaclass->VERSION) {
	my $given_version = Moose::Exception::MetaclassIsAClassNotASubclassOfGivenMetaclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassIsAClassNotASubclassOfGivenMetaclass->VERSION . '
');

}
print("import: Moose::Exception::MetaclassIsARoleNotASubclassOfGivenMetaclass\n");
use Moose::Exception::MetaclassIsARoleNotASubclassOfGivenMetaclass;

if (defined Moose::Exception::MetaclassIsARoleNotASubclassOfGivenMetaclass->VERSION) {
	my $given_version = Moose::Exception::MetaclassIsARoleNotASubclassOfGivenMetaclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassIsARoleNotASubclassOfGivenMetaclass->VERSION . '
');

}
print("import: Moose::Exception::MetaclassIsNotASubclassOfGivenMetaclass\n");
use Moose::Exception::MetaclassIsNotASubclassOfGivenMetaclass;

if (defined Moose::Exception::MetaclassIsNotASubclassOfGivenMetaclass->VERSION) {
	my $given_version = Moose::Exception::MetaclassIsNotASubclassOfGivenMetaclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassIsNotASubclassOfGivenMetaclass->VERSION . '
');

}
print("import: Moose::Exception::MetaclassMustBeASubclassOfMooseMetaClass\n");
use Moose::Exception::MetaclassMustBeASubclassOfMooseMetaClass;

if (defined Moose::Exception::MetaclassMustBeASubclassOfMooseMetaClass->VERSION) {
	my $given_version = Moose::Exception::MetaclassMustBeASubclassOfMooseMetaClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassMustBeASubclassOfMooseMetaClass->VERSION . '
');

}
print("import: Moose::Exception::MetaclassMustBeASubclassOfMooseMetaRole\n");
use Moose::Exception::MetaclassMustBeASubclassOfMooseMetaRole;

if (defined Moose::Exception::MetaclassMustBeASubclassOfMooseMetaRole->VERSION) {
	my $given_version = Moose::Exception::MetaclassMustBeASubclassOfMooseMetaRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassMustBeASubclassOfMooseMetaRole->VERSION . '
');

}
print("import: Moose::Exception::MetaclassMustBeDerivedFromClassMOPClass\n");
use Moose::Exception::MetaclassMustBeDerivedFromClassMOPClass;

if (defined Moose::Exception::MetaclassMustBeDerivedFromClassMOPClass->VERSION) {
	my $given_version = Moose::Exception::MetaclassMustBeDerivedFromClassMOPClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassMustBeDerivedFromClassMOPClass->VERSION . '
');

}
print("import: Moose::Exception::MetaclassNotLoaded\n");
use Moose::Exception::MetaclassNotLoaded;

if (defined Moose::Exception::MetaclassNotLoaded->VERSION) {
	my $given_version = Moose::Exception::MetaclassNotLoaded->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassNotLoaded->VERSION . '
');

}
print("import: Moose::Exception::MetaclassTypeIncompatible\n");
use Moose::Exception::MetaclassTypeIncompatible;

if (defined Moose::Exception::MetaclassTypeIncompatible->VERSION) {
	my $given_version = Moose::Exception::MetaclassTypeIncompatible->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MetaclassTypeIncompatible->VERSION . '
');

}
print("import: Moose::Exception::MethodExpectedAMetaclassObject\n");
use Moose::Exception::MethodExpectedAMetaclassObject;

if (defined Moose::Exception::MethodExpectedAMetaclassObject->VERSION) {
	my $given_version = Moose::Exception::MethodExpectedAMetaclassObject->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MethodExpectedAMetaclassObject->VERSION . '
');

}
print("import: Moose::Exception::MethodExpectsFewerArgs\n");
use Moose::Exception::MethodExpectsFewerArgs;

if (defined Moose::Exception::MethodExpectsFewerArgs->VERSION) {
	my $given_version = Moose::Exception::MethodExpectsFewerArgs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MethodExpectsFewerArgs->VERSION . '
');

}
print("import: Moose::Exception::MethodExpectsMoreArgs\n");
use Moose::Exception::MethodExpectsMoreArgs;

if (defined Moose::Exception::MethodExpectsMoreArgs->VERSION) {
	my $given_version = Moose::Exception::MethodExpectsMoreArgs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MethodExpectsMoreArgs->VERSION . '
');

}
print("import: Moose::Exception::MethodModifierNeedsMethodName\n");
use Moose::Exception::MethodModifierNeedsMethodName;

if (defined Moose::Exception::MethodModifierNeedsMethodName->VERSION) {
	my $given_version = Moose::Exception::MethodModifierNeedsMethodName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MethodModifierNeedsMethodName->VERSION . '
');

}
print("import: Moose::Exception::MethodNameConflictInRoles\n");
use Moose::Exception::MethodNameConflictInRoles;

if (defined Moose::Exception::MethodNameConflictInRoles->VERSION) {
	my $given_version = Moose::Exception::MethodNameConflictInRoles->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MethodNameConflictInRoles->VERSION . '
');

}
print("import: Moose::Exception::MethodNameNotFoundInInheritanceHierarchy\n");
use Moose::Exception::MethodNameNotFoundInInheritanceHierarchy;

if (defined Moose::Exception::MethodNameNotFoundInInheritanceHierarchy->VERSION) {
	my $given_version = Moose::Exception::MethodNameNotFoundInInheritanceHierarchy->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MethodNameNotFoundInInheritanceHierarchy->VERSION . '
');

}
print("import: Moose::Exception::MethodNameNotGiven\n");
use Moose::Exception::MethodNameNotGiven;

if (defined Moose::Exception::MethodNameNotGiven->VERSION) {
	my $given_version = Moose::Exception::MethodNameNotGiven->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MethodNameNotGiven->VERSION . '
');

}
print("import: Moose::Exception::MustDefineAMethodName\n");
use Moose::Exception::MustDefineAMethodName;

if (defined Moose::Exception::MustDefineAMethodName->VERSION) {
	my $given_version = Moose::Exception::MustDefineAMethodName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustDefineAMethodName->VERSION . '
');

}
print("import: Moose::Exception::MustDefineAnAttributeName\n");
use Moose::Exception::MustDefineAnAttributeName;

if (defined Moose::Exception::MustDefineAnAttributeName->VERSION) {
	my $given_version = Moose::Exception::MustDefineAnAttributeName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustDefineAnAttributeName->VERSION . '
');

}
print("import: Moose::Exception::MustDefineAnOverloadOperator\n");
use Moose::Exception::MustDefineAnOverloadOperator;

if (defined Moose::Exception::MustDefineAnOverloadOperator->VERSION) {
	my $given_version = Moose::Exception::MustDefineAnOverloadOperator->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustDefineAnOverloadOperator->VERSION . '
');

}
print("import: Moose::Exception::MustHaveAtLeastOneValueToEnumerate\n");
use Moose::Exception::MustHaveAtLeastOneValueToEnumerate;

if (defined Moose::Exception::MustHaveAtLeastOneValueToEnumerate->VERSION) {
	my $given_version = Moose::Exception::MustHaveAtLeastOneValueToEnumerate->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustHaveAtLeastOneValueToEnumerate->VERSION . '
');

}
print("import: Moose::Exception::MustPassAHashOfOptions\n");
use Moose::Exception::MustPassAHashOfOptions;

if (defined Moose::Exception::MustPassAHashOfOptions->VERSION) {
	my $given_version = Moose::Exception::MustPassAHashOfOptions->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustPassAHashOfOptions->VERSION . '
');

}
print("import: Moose::Exception::MustPassAMooseMetaRoleInstanceOrSubclass\n");
use Moose::Exception::MustPassAMooseMetaRoleInstanceOrSubclass;

if (defined Moose::Exception::MustPassAMooseMetaRoleInstanceOrSubclass->VERSION) {
	my $given_version = Moose::Exception::MustPassAMooseMetaRoleInstanceOrSubclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustPassAMooseMetaRoleInstanceOrSubclass->VERSION . '
');

}
print("import: Moose::Exception::MustPassAPackageNameOrAnExistingClassMOPPackageInstance\n");
use Moose::Exception::MustPassAPackageNameOrAnExistingClassMOPPackageInstance;

if (defined Moose::Exception::MustPassAPackageNameOrAnExistingClassMOPPackageInstance->VERSION) {
	my $given_version = Moose::Exception::MustPassAPackageNameOrAnExistingClassMOPPackageInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustPassAPackageNameOrAnExistingClassMOPPackageInstance->VERSION . '
');

}
print("import: Moose::Exception::MustPassEvenNumberOfArguments\n");
use Moose::Exception::MustPassEvenNumberOfArguments;

if (defined Moose::Exception::MustPassEvenNumberOfArguments->VERSION) {
	my $given_version = Moose::Exception::MustPassEvenNumberOfArguments->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustPassEvenNumberOfArguments->VERSION . '
');

}
print("import: Moose::Exception::MustPassEvenNumberOfAttributeOptions\n");
use Moose::Exception::MustPassEvenNumberOfAttributeOptions;

if (defined Moose::Exception::MustPassEvenNumberOfAttributeOptions->VERSION) {
	my $given_version = Moose::Exception::MustPassEvenNumberOfAttributeOptions->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustPassEvenNumberOfAttributeOptions->VERSION . '
');

}
print("import: Moose::Exception::MustProvideANameForTheAttribute\n");
use Moose::Exception::MustProvideANameForTheAttribute;

if (defined Moose::Exception::MustProvideANameForTheAttribute->VERSION) {
	my $given_version = Moose::Exception::MustProvideANameForTheAttribute->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustProvideANameForTheAttribute->VERSION . '
');

}
print("import: Moose::Exception::MustSpecifyAtleastOneMethod\n");
use Moose::Exception::MustSpecifyAtleastOneMethod;

if (defined Moose::Exception::MustSpecifyAtleastOneMethod->VERSION) {
	my $given_version = Moose::Exception::MustSpecifyAtleastOneMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSpecifyAtleastOneMethod->VERSION . '
');

}
print("import: Moose::Exception::MustSpecifyAtleastOneRole\n");
use Moose::Exception::MustSpecifyAtleastOneRole;

if (defined Moose::Exception::MustSpecifyAtleastOneRole->VERSION) {
	my $given_version = Moose::Exception::MustSpecifyAtleastOneRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSpecifyAtleastOneRole->VERSION . '
');

}
print("import: Moose::Exception::MustSpecifyAtleastOneRoleToApplicant\n");
use Moose::Exception::MustSpecifyAtleastOneRoleToApplicant;

if (defined Moose::Exception::MustSpecifyAtleastOneRoleToApplicant->VERSION) {
	my $given_version = Moose::Exception::MustSpecifyAtleastOneRoleToApplicant->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSpecifyAtleastOneRoleToApplicant->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyAClassMOPAttributeInstance\n");
use Moose::Exception::MustSupplyAClassMOPAttributeInstance;

if (defined Moose::Exception::MustSupplyAClassMOPAttributeInstance->VERSION) {
	my $given_version = Moose::Exception::MustSupplyAClassMOPAttributeInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyAClassMOPAttributeInstance->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyADelegateToMethod\n");
use Moose::Exception::MustSupplyADelegateToMethod;

if (defined Moose::Exception::MustSupplyADelegateToMethod->VERSION) {
	my $given_version = Moose::Exception::MustSupplyADelegateToMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyADelegateToMethod->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyAMetaclass\n");
use Moose::Exception::MustSupplyAMetaclass;

if (defined Moose::Exception::MustSupplyAMetaclass->VERSION) {
	my $given_version = Moose::Exception::MustSupplyAMetaclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyAMetaclass->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyAMooseMetaAttributeInstance\n");
use Moose::Exception::MustSupplyAMooseMetaAttributeInstance;

if (defined Moose::Exception::MustSupplyAMooseMetaAttributeInstance->VERSION) {
	my $given_version = Moose::Exception::MustSupplyAMooseMetaAttributeInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyAMooseMetaAttributeInstance->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyAnAccessorTypeToConstructWith\n");
use Moose::Exception::MustSupplyAnAccessorTypeToConstructWith;

if (defined Moose::Exception::MustSupplyAnAccessorTypeToConstructWith->VERSION) {
	my $given_version = Moose::Exception::MustSupplyAnAccessorTypeToConstructWith->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyAnAccessorTypeToConstructWith->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyAnAttributeToConstructWith\n");
use Moose::Exception::MustSupplyAnAttributeToConstructWith;

if (defined Moose::Exception::MustSupplyAnAttributeToConstructWith->VERSION) {
	my $given_version = Moose::Exception::MustSupplyAnAttributeToConstructWith->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyAnAttributeToConstructWith->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyArrayRefAsCurriedArguments\n");
use Moose::Exception::MustSupplyArrayRefAsCurriedArguments;

if (defined Moose::Exception::MustSupplyArrayRefAsCurriedArguments->VERSION) {
	my $given_version = Moose::Exception::MustSupplyArrayRefAsCurriedArguments->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyArrayRefAsCurriedArguments->VERSION . '
');

}
print("import: Moose::Exception::MustSupplyPackageNameAndName\n");
use Moose::Exception::MustSupplyPackageNameAndName;

if (defined Moose::Exception::MustSupplyPackageNameAndName->VERSION) {
	my $given_version = Moose::Exception::MustSupplyPackageNameAndName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::MustSupplyPackageNameAndName->VERSION . '
');

}
print("import: Moose::Exception::NeedsTypeConstraintUnionForTypeCoercionUnion\n");
use Moose::Exception::NeedsTypeConstraintUnionForTypeCoercionUnion;

if (defined Moose::Exception::NeedsTypeConstraintUnionForTypeCoercionUnion->VERSION) {
	my $given_version = Moose::Exception::NeedsTypeConstraintUnionForTypeCoercionUnion->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NeedsTypeConstraintUnionForTypeCoercionUnion->VERSION . '
');

}
print("import: Moose::Exception::NeitherAttributeNorAttributeNameIsGiven\n");
use Moose::Exception::NeitherAttributeNorAttributeNameIsGiven;

if (defined Moose::Exception::NeitherAttributeNorAttributeNameIsGiven->VERSION) {
	my $given_version = Moose::Exception::NeitherAttributeNorAttributeNameIsGiven->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NeitherAttributeNorAttributeNameIsGiven->VERSION . '
');

}
print("import: Moose::Exception::NeitherClassNorClassNameIsGiven\n");
use Moose::Exception::NeitherClassNorClassNameIsGiven;

if (defined Moose::Exception::NeitherClassNorClassNameIsGiven->VERSION) {
	my $given_version = Moose::Exception::NeitherClassNorClassNameIsGiven->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NeitherClassNorClassNameIsGiven->VERSION . '
');

}
print("import: Moose::Exception::NeitherRoleNorRoleNameIsGiven\n");
use Moose::Exception::NeitherRoleNorRoleNameIsGiven;

if (defined Moose::Exception::NeitherRoleNorRoleNameIsGiven->VERSION) {
	my $given_version = Moose::Exception::NeitherRoleNorRoleNameIsGiven->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NeitherRoleNorRoleNameIsGiven->VERSION . '
');

}
print("import: Moose::Exception::NeitherTypeNorTypeNameIsGiven\n");
use Moose::Exception::NeitherTypeNorTypeNameIsGiven;

if (defined Moose::Exception::NeitherTypeNorTypeNameIsGiven->VERSION) {
	my $given_version = Moose::Exception::NeitherTypeNorTypeNameIsGiven->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NeitherTypeNorTypeNameIsGiven->VERSION . '
');

}
print("import: Moose::Exception::NoAttributeFoundInSuperClass\n");
use Moose::Exception::NoAttributeFoundInSuperClass;

if (defined Moose::Exception::NoAttributeFoundInSuperClass->VERSION) {
	my $given_version = Moose::Exception::NoAttributeFoundInSuperClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NoAttributeFoundInSuperClass->VERSION . '
');

}
print("import: Moose::Exception::NoBodyToInitializeInAnAbstractBaseClass\n");
use Moose::Exception::NoBodyToInitializeInAnAbstractBaseClass;

if (defined Moose::Exception::NoBodyToInitializeInAnAbstractBaseClass->VERSION) {
	my $given_version = Moose::Exception::NoBodyToInitializeInAnAbstractBaseClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NoBodyToInitializeInAnAbstractBaseClass->VERSION . '
');

}
print("import: Moose::Exception::NoCasesMatched\n");
use Moose::Exception::NoCasesMatched;

if (defined Moose::Exception::NoCasesMatched->VERSION) {
	my $given_version = Moose::Exception::NoCasesMatched->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NoCasesMatched->VERSION . '
');

}
print("import: Moose::Exception::NoConstraintCheckForTypeConstraint\n");
use Moose::Exception::NoConstraintCheckForTypeConstraint;

if (defined Moose::Exception::NoConstraintCheckForTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::NoConstraintCheckForTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NoConstraintCheckForTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::NoDestructorClassSpecified\n");
use Moose::Exception::NoDestructorClassSpecified;

if (defined Moose::Exception::NoDestructorClassSpecified->VERSION) {
	my $given_version = Moose::Exception::NoDestructorClassSpecified->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NoDestructorClassSpecified->VERSION . '
');

}
print("import: Moose::Exception::NoImmutableTraitSpecifiedForClass\n");
use Moose::Exception::NoImmutableTraitSpecifiedForClass;

if (defined Moose::Exception::NoImmutableTraitSpecifiedForClass->VERSION) {
	my $given_version = Moose::Exception::NoImmutableTraitSpecifiedForClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NoImmutableTraitSpecifiedForClass->VERSION . '
');

}
print("import: Moose::Exception::NoParentGivenToSubtype\n");
use Moose::Exception::NoParentGivenToSubtype;

if (defined Moose::Exception::NoParentGivenToSubtype->VERSION) {
	my $given_version = Moose::Exception::NoParentGivenToSubtype->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::NoParentGivenToSubtype->VERSION . '
');

}
print("import: Moose::Exception::OnlyInstancesCanBeCloned\n");
use Moose::Exception::OnlyInstancesCanBeCloned;

if (defined Moose::Exception::OnlyInstancesCanBeCloned->VERSION) {
	my $given_version = Moose::Exception::OnlyInstancesCanBeCloned->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OnlyInstancesCanBeCloned->VERSION . '
');

}
print("import: Moose::Exception::OperatorIsRequired\n");
use Moose::Exception::OperatorIsRequired;

if (defined Moose::Exception::OperatorIsRequired->VERSION) {
	my $given_version = Moose::Exception::OperatorIsRequired->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OperatorIsRequired->VERSION . '
');

}
print("import: Moose::Exception::OverloadConflictInSummation\n");
use Moose::Exception::OverloadConflictInSummation;

if (defined Moose::Exception::OverloadConflictInSummation->VERSION) {
	my $given_version = Moose::Exception::OverloadConflictInSummation->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverloadConflictInSummation->VERSION . '
');

}
print("import: Moose::Exception::OverloadRequiresAMetaClass\n");
use Moose::Exception::OverloadRequiresAMetaClass;

if (defined Moose::Exception::OverloadRequiresAMetaClass->VERSION) {
	my $given_version = Moose::Exception::OverloadRequiresAMetaClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverloadRequiresAMetaClass->VERSION . '
');

}
print("import: Moose::Exception::OverloadRequiresAMetaMethod\n");
use Moose::Exception::OverloadRequiresAMetaMethod;

if (defined Moose::Exception::OverloadRequiresAMetaMethod->VERSION) {
	my $given_version = Moose::Exception::OverloadRequiresAMetaMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverloadRequiresAMetaMethod->VERSION . '
');

}
print("import: Moose::Exception::OverloadRequiresAMetaOverload\n");
use Moose::Exception::OverloadRequiresAMetaOverload;

if (defined Moose::Exception::OverloadRequiresAMetaOverload->VERSION) {
	my $given_version = Moose::Exception::OverloadRequiresAMetaOverload->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverloadRequiresAMetaOverload->VERSION . '
');

}
print("import: Moose::Exception::OverloadRequiresAMethodNameOrCoderef\n");
use Moose::Exception::OverloadRequiresAMethodNameOrCoderef;

if (defined Moose::Exception::OverloadRequiresAMethodNameOrCoderef->VERSION) {
	my $given_version = Moose::Exception::OverloadRequiresAMethodNameOrCoderef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverloadRequiresAMethodNameOrCoderef->VERSION . '
');

}
print("import: Moose::Exception::OverloadRequiresAnOperator\n");
use Moose::Exception::OverloadRequiresAnOperator;

if (defined Moose::Exception::OverloadRequiresAnOperator->VERSION) {
	my $given_version = Moose::Exception::OverloadRequiresAnOperator->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverloadRequiresAnOperator->VERSION . '
');

}
print("import: Moose::Exception::OverloadRequiresNamesForCoderef\n");
use Moose::Exception::OverloadRequiresNamesForCoderef;

if (defined Moose::Exception::OverloadRequiresNamesForCoderef->VERSION) {
	my $given_version = Moose::Exception::OverloadRequiresNamesForCoderef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverloadRequiresNamesForCoderef->VERSION . '
');

}
print("import: Moose::Exception::OverrideConflictInComposition\n");
use Moose::Exception::OverrideConflictInComposition;

if (defined Moose::Exception::OverrideConflictInComposition->VERSION) {
	my $given_version = Moose::Exception::OverrideConflictInComposition->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverrideConflictInComposition->VERSION . '
');

}
print("import: Moose::Exception::OverrideConflictInSummation\n");
use Moose::Exception::OverrideConflictInSummation;

if (defined Moose::Exception::OverrideConflictInSummation->VERSION) {
	my $given_version = Moose::Exception::OverrideConflictInSummation->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::OverrideConflictInSummation->VERSION . '
');

}
print("import: Moose::Exception::PackageDoesNotUseMooseExporter\n");
use Moose::Exception::PackageDoesNotUseMooseExporter;

if (defined Moose::Exception::PackageDoesNotUseMooseExporter->VERSION) {
	my $given_version = Moose::Exception::PackageDoesNotUseMooseExporter->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::PackageDoesNotUseMooseExporter->VERSION . '
');

}
print("import: Moose::Exception::PackageNameAndNameParamsNotGivenToWrap\n");
use Moose::Exception::PackageNameAndNameParamsNotGivenToWrap;

if (defined Moose::Exception::PackageNameAndNameParamsNotGivenToWrap->VERSION) {
	my $given_version = Moose::Exception::PackageNameAndNameParamsNotGivenToWrap->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::PackageNameAndNameParamsNotGivenToWrap->VERSION . '
');

}
print("import: Moose::Exception::PackagesAndModulesAreNotCachable\n");
use Moose::Exception::PackagesAndModulesAreNotCachable;

if (defined Moose::Exception::PackagesAndModulesAreNotCachable->VERSION) {
	my $given_version = Moose::Exception::PackagesAndModulesAreNotCachable->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::PackagesAndModulesAreNotCachable->VERSION . '
');

}
print("import: Moose::Exception::ParameterIsNotSubtypeOfParent\n");
use Moose::Exception::ParameterIsNotSubtypeOfParent;

if (defined Moose::Exception::ParameterIsNotSubtypeOfParent->VERSION) {
	my $given_version = Moose::Exception::ParameterIsNotSubtypeOfParent->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ParameterIsNotSubtypeOfParent->VERSION . '
');

}
print("import: Moose::Exception::ReferencesAreNotAllowedAsDefault\n");
use Moose::Exception::ReferencesAreNotAllowedAsDefault;

if (defined Moose::Exception::ReferencesAreNotAllowedAsDefault->VERSION) {
	my $given_version = Moose::Exception::ReferencesAreNotAllowedAsDefault->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ReferencesAreNotAllowedAsDefault->VERSION . '
');

}
print("import: Moose::Exception::RequiredAttributeLacksInitialization\n");
use Moose::Exception::RequiredAttributeLacksInitialization;

if (defined Moose::Exception::RequiredAttributeLacksInitialization->VERSION) {
	my $given_version = Moose::Exception::RequiredAttributeLacksInitialization->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RequiredAttributeLacksInitialization->VERSION . '
');

}
print("import: Moose::Exception::RequiredAttributeNeedsADefault\n");
use Moose::Exception::RequiredAttributeNeedsADefault;

if (defined Moose::Exception::RequiredAttributeNeedsADefault->VERSION) {
	my $given_version = Moose::Exception::RequiredAttributeNeedsADefault->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RequiredAttributeNeedsADefault->VERSION . '
');

}
print("import: Moose::Exception::RequiredMethodsImportedByClass\n");
use Moose::Exception::RequiredMethodsImportedByClass;

if (defined Moose::Exception::RequiredMethodsImportedByClass->VERSION) {
	my $given_version = Moose::Exception::RequiredMethodsImportedByClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RequiredMethodsImportedByClass->VERSION . '
');

}
print("import: Moose::Exception::RequiredMethodsNotImplementedByClass\n");
use Moose::Exception::RequiredMethodsNotImplementedByClass;

if (defined Moose::Exception::RequiredMethodsNotImplementedByClass->VERSION) {
	my $given_version = Moose::Exception::RequiredMethodsNotImplementedByClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RequiredMethodsNotImplementedByClass->VERSION . '
');

}
print("import: Moose::Exception::Role::Attribute\n");
use Moose::Exception::Role::Attribute;

if (defined Moose::Exception::Role::Attribute->VERSION) {
	my $given_version = Moose::Exception::Role::Attribute->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::Attribute->VERSION . '
');

}
print("import: Moose::Exception::Role::AttributeName\n");
use Moose::Exception::Role::AttributeName;

if (defined Moose::Exception::Role::AttributeName->VERSION) {
	my $given_version = Moose::Exception::Role::AttributeName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::AttributeName->VERSION . '
');

}
print("import: Moose::Exception::Role::Class\n");
use Moose::Exception::Role::Class;

if (defined Moose::Exception::Role::Class->VERSION) {
	my $given_version = Moose::Exception::Role::Class->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::Class->VERSION . '
');

}
print("import: Moose::Exception::Role::EitherAttributeOrAttributeName\n");
use Moose::Exception::Role::EitherAttributeOrAttributeName;

if (defined Moose::Exception::Role::EitherAttributeOrAttributeName->VERSION) {
	my $given_version = Moose::Exception::Role::EitherAttributeOrAttributeName->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::EitherAttributeOrAttributeName->VERSION . '
');

}
print("import: Moose::Exception::Role::Instance\n");
use Moose::Exception::Role::Instance;

if (defined Moose::Exception::Role::Instance->VERSION) {
	my $given_version = Moose::Exception::Role::Instance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::Instance->VERSION . '
');

}
print("import: Moose::Exception::Role::InstanceClass\n");
use Moose::Exception::Role::InstanceClass;

if (defined Moose::Exception::Role::InstanceClass->VERSION) {
	my $given_version = Moose::Exception::Role::InstanceClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::InstanceClass->VERSION . '
');

}
print("import: Moose::Exception::Role::InvalidAttributeOptions\n");
use Moose::Exception::Role::InvalidAttributeOptions;

if (defined Moose::Exception::Role::InvalidAttributeOptions->VERSION) {
	my $given_version = Moose::Exception::Role::InvalidAttributeOptions->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::InvalidAttributeOptions->VERSION . '
');

}
print("import: Moose::Exception::Role::Method\n");
use Moose::Exception::Role::Method;

if (defined Moose::Exception::Role::Method->VERSION) {
	my $given_version = Moose::Exception::Role::Method->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::Method->VERSION . '
');

}
print("import: Moose::Exception::Role::ParamsHash\n");
use Moose::Exception::Role::ParamsHash;

if (defined Moose::Exception::Role::ParamsHash->VERSION) {
	my $given_version = Moose::Exception::Role::ParamsHash->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::ParamsHash->VERSION . '
');

}
print("import: Moose::Exception::Role::Role\n");
use Moose::Exception::Role::Role;

if (defined Moose::Exception::Role::Role->VERSION) {
	my $given_version = Moose::Exception::Role::Role->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::Role->VERSION . '
');

}
print("import: Moose::Exception::Role::RoleForCreate\n");
use Moose::Exception::Role::RoleForCreate;

if (defined Moose::Exception::Role::RoleForCreate->VERSION) {
	my $given_version = Moose::Exception::Role::RoleForCreate->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::RoleForCreate->VERSION . '
');

}
print("import: Moose::Exception::Role::RoleForCreateMOPClass\n");
use Moose::Exception::Role::RoleForCreateMOPClass;

if (defined Moose::Exception::Role::RoleForCreateMOPClass->VERSION) {
	my $given_version = Moose::Exception::Role::RoleForCreateMOPClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::RoleForCreateMOPClass->VERSION . '
');

}
print("import: Moose::Exception::Role::TypeConstraint\n");
use Moose::Exception::Role::TypeConstraint;

if (defined Moose::Exception::Role::TypeConstraint->VERSION) {
	my $given_version = Moose::Exception::Role::TypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::Role::TypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::RoleDoesTheExcludedRole\n");
use Moose::Exception::RoleDoesTheExcludedRole;

if (defined Moose::Exception::RoleDoesTheExcludedRole->VERSION) {
	my $given_version = Moose::Exception::RoleDoesTheExcludedRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RoleDoesTheExcludedRole->VERSION . '
');

}
print("import: Moose::Exception::RoleExclusionConflict\n");
use Moose::Exception::RoleExclusionConflict;

if (defined Moose::Exception::RoleExclusionConflict->VERSION) {
	my $given_version = Moose::Exception::RoleExclusionConflict->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RoleExclusionConflict->VERSION . '
');

}
print("import: Moose::Exception::RoleNameRequired\n");
use Moose::Exception::RoleNameRequired;

if (defined Moose::Exception::RoleNameRequired->VERSION) {
	my $given_version = Moose::Exception::RoleNameRequired->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RoleNameRequired->VERSION . '
');

}
print("import: Moose::Exception::RoleNameRequiredForMooseMetaRole\n");
use Moose::Exception::RoleNameRequiredForMooseMetaRole;

if (defined Moose::Exception::RoleNameRequiredForMooseMetaRole->VERSION) {
	my $given_version = Moose::Exception::RoleNameRequiredForMooseMetaRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RoleNameRequiredForMooseMetaRole->VERSION . '
');

}
print("import: Moose::Exception::RolesDoNotSupportAugment\n");
use Moose::Exception::RolesDoNotSupportAugment;

if (defined Moose::Exception::RolesDoNotSupportAugment->VERSION) {
	my $given_version = Moose::Exception::RolesDoNotSupportAugment->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RolesDoNotSupportAugment->VERSION . '
');

}
print("import: Moose::Exception::RolesDoNotSupportExtends\n");
use Moose::Exception::RolesDoNotSupportExtends;

if (defined Moose::Exception::RolesDoNotSupportExtends->VERSION) {
	my $given_version = Moose::Exception::RolesDoNotSupportExtends->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RolesDoNotSupportExtends->VERSION . '
');

}
print("import: Moose::Exception::RolesDoNotSupportInner\n");
use Moose::Exception::RolesDoNotSupportInner;

if (defined Moose::Exception::RolesDoNotSupportInner->VERSION) {
	my $given_version = Moose::Exception::RolesDoNotSupportInner->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RolesDoNotSupportInner->VERSION . '
');

}
print("import: Moose::Exception::RolesDoNotSupportRegexReferencesForMethodModifiers\n");
use Moose::Exception::RolesDoNotSupportRegexReferencesForMethodModifiers;

if (defined Moose::Exception::RolesDoNotSupportRegexReferencesForMethodModifiers->VERSION) {
	my $given_version = Moose::Exception::RolesDoNotSupportRegexReferencesForMethodModifiers->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RolesDoNotSupportRegexReferencesForMethodModifiers->VERSION . '
');

}
print("import: Moose::Exception::RolesInCreateTakesAnArrayRef\n");
use Moose::Exception::RolesInCreateTakesAnArrayRef;

if (defined Moose::Exception::RolesInCreateTakesAnArrayRef->VERSION) {
	my $given_version = Moose::Exception::RolesInCreateTakesAnArrayRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RolesInCreateTakesAnArrayRef->VERSION . '
');

}
print("import: Moose::Exception::RolesListMustBeInstancesOfMooseMetaRole\n");
use Moose::Exception::RolesListMustBeInstancesOfMooseMetaRole;

if (defined Moose::Exception::RolesListMustBeInstancesOfMooseMetaRole->VERSION) {
	my $given_version = Moose::Exception::RolesListMustBeInstancesOfMooseMetaRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::RolesListMustBeInstancesOfMooseMetaRole->VERSION . '
');

}
print("import: Moose::Exception::SingleParamsToNewMustBeHashRef\n");
use Moose::Exception::SingleParamsToNewMustBeHashRef;

if (defined Moose::Exception::SingleParamsToNewMustBeHashRef->VERSION) {
	my $given_version = Moose::Exception::SingleParamsToNewMustBeHashRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::SingleParamsToNewMustBeHashRef->VERSION . '
');

}
print("import: Moose::Exception::TriggerMustBeACodeRef\n");
use Moose::Exception::TriggerMustBeACodeRef;

if (defined Moose::Exception::TriggerMustBeACodeRef->VERSION) {
	my $given_version = Moose::Exception::TriggerMustBeACodeRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::TriggerMustBeACodeRef->VERSION . '
');

}
print("import: Moose::Exception::TypeConstraintCannotBeUsedForAParameterizableType\n");
use Moose::Exception::TypeConstraintCannotBeUsedForAParameterizableType;

if (defined Moose::Exception::TypeConstraintCannotBeUsedForAParameterizableType->VERSION) {
	my $given_version = Moose::Exception::TypeConstraintCannotBeUsedForAParameterizableType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::TypeConstraintCannotBeUsedForAParameterizableType->VERSION . '
');

}
print("import: Moose::Exception::TypeConstraintIsAlreadyCreated\n");
use Moose::Exception::TypeConstraintIsAlreadyCreated;

if (defined Moose::Exception::TypeConstraintIsAlreadyCreated->VERSION) {
	my $given_version = Moose::Exception::TypeConstraintIsAlreadyCreated->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::TypeConstraintIsAlreadyCreated->VERSION . '
');

}
print("import: Moose::Exception::TypeParameterMustBeMooseMetaType\n");
use Moose::Exception::TypeParameterMustBeMooseMetaType;

if (defined Moose::Exception::TypeParameterMustBeMooseMetaType->VERSION) {
	my $given_version = Moose::Exception::TypeParameterMustBeMooseMetaType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::TypeParameterMustBeMooseMetaType->VERSION . '
');

}
print("import: Moose::Exception::UnableToCanonicalizeHandles\n");
use Moose::Exception::UnableToCanonicalizeHandles;

if (defined Moose::Exception::UnableToCanonicalizeHandles->VERSION) {
	my $given_version = Moose::Exception::UnableToCanonicalizeHandles->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::UnableToCanonicalizeHandles->VERSION . '
');

}
print("import: Moose::Exception::UnableToCanonicalizeNonRolePackage\n");
use Moose::Exception::UnableToCanonicalizeNonRolePackage;

if (defined Moose::Exception::UnableToCanonicalizeNonRolePackage->VERSION) {
	my $given_version = Moose::Exception::UnableToCanonicalizeNonRolePackage->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::UnableToCanonicalizeNonRolePackage->VERSION . '
');

}
print("import: Moose::Exception::UnableToRecognizeDelegateMetaclass\n");
use Moose::Exception::UnableToRecognizeDelegateMetaclass;

if (defined Moose::Exception::UnableToRecognizeDelegateMetaclass->VERSION) {
	my $given_version = Moose::Exception::UnableToRecognizeDelegateMetaclass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::UnableToRecognizeDelegateMetaclass->VERSION . '
');

}
print("import: Moose::Exception::UndefinedHashKeysPassedToMethod\n");
use Moose::Exception::UndefinedHashKeysPassedToMethod;

if (defined Moose::Exception::UndefinedHashKeysPassedToMethod->VERSION) {
	my $given_version = Moose::Exception::UndefinedHashKeysPassedToMethod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::UndefinedHashKeysPassedToMethod->VERSION . '
');

}
print("import: Moose::Exception::UnionCalledWithAnArrayRefAndAdditionalArgs\n");
use Moose::Exception::UnionCalledWithAnArrayRefAndAdditionalArgs;

if (defined Moose::Exception::UnionCalledWithAnArrayRefAndAdditionalArgs->VERSION) {
	my $given_version = Moose::Exception::UnionCalledWithAnArrayRefAndAdditionalArgs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::UnionCalledWithAnArrayRefAndAdditionalArgs->VERSION . '
');

}
print("import: Moose::Exception::UnionTakesAtleastTwoTypeNames\n");
use Moose::Exception::UnionTakesAtleastTwoTypeNames;

if (defined Moose::Exception::UnionTakesAtleastTwoTypeNames->VERSION) {
	my $given_version = Moose::Exception::UnionTakesAtleastTwoTypeNames->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::UnionTakesAtleastTwoTypeNames->VERSION . '
');

}
print("import: Moose::Exception::ValidationFailedForInlineTypeConstraint\n");
use Moose::Exception::ValidationFailedForInlineTypeConstraint;

if (defined Moose::Exception::ValidationFailedForInlineTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::ValidationFailedForInlineTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ValidationFailedForInlineTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::ValidationFailedForTypeConstraint\n");
use Moose::Exception::ValidationFailedForTypeConstraint;

if (defined Moose::Exception::ValidationFailedForTypeConstraint->VERSION) {
	my $given_version = Moose::Exception::ValidationFailedForTypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::ValidationFailedForTypeConstraint->VERSION . '
');

}
print("import: Moose::Exception::WrapTakesACodeRefToBless\n");
use Moose::Exception::WrapTakesACodeRefToBless;

if (defined Moose::Exception::WrapTakesACodeRefToBless->VERSION) {
	my $given_version = Moose::Exception::WrapTakesACodeRefToBless->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::WrapTakesACodeRefToBless->VERSION . '
');

}
print("import: Moose::Exception::WrongTypeConstraintGiven\n");
use Moose::Exception::WrongTypeConstraintGiven;

if (defined Moose::Exception::WrongTypeConstraintGiven->VERSION) {
	my $given_version = Moose::Exception::WrongTypeConstraintGiven->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exception::WrongTypeConstraintGiven->VERSION . '
');

}
print("import: Moose::Exporter\n");
use Moose::Exporter;

if (defined Moose::Exporter->VERSION) {
	my $given_version = Moose::Exporter->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Exporter->VERSION . '
');

}
print("import: Moose::Meta::Attribute\n");
use Moose::Meta::Attribute;

if (defined Moose::Meta::Attribute->VERSION) {
	my $given_version = Moose::Meta::Attribute->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native\n");
use Moose::Meta::Attribute::Native;

if (defined Moose::Meta::Attribute::Native->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait\n");
use Moose::Meta::Attribute::Native::Trait;

if (defined Moose::Meta::Attribute::Native::Trait->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait::Array\n");
use Moose::Meta::Attribute::Native::Trait::Array;

if (defined Moose::Meta::Attribute::Native::Trait::Array->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait::Array->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait::Array->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait::Bool\n");
use Moose::Meta::Attribute::Native::Trait::Bool;

if (defined Moose::Meta::Attribute::Native::Trait::Bool->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait::Bool->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait::Bool->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait::Code\n");
use Moose::Meta::Attribute::Native::Trait::Code;

if (defined Moose::Meta::Attribute::Native::Trait::Code->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait::Code->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait::Code->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait::Counter\n");
use Moose::Meta::Attribute::Native::Trait::Counter;

if (defined Moose::Meta::Attribute::Native::Trait::Counter->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait::Counter->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait::Counter->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait::Hash\n");
use Moose::Meta::Attribute::Native::Trait::Hash;

if (defined Moose::Meta::Attribute::Native::Trait::Hash->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait::Hash->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait::Hash->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait::Number\n");
use Moose::Meta::Attribute::Native::Trait::Number;

if (defined Moose::Meta::Attribute::Native::Trait::Number->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait::Number->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait::Number->VERSION . '
');

}
print("import: Moose::Meta::Attribute::Native::Trait::String\n");
use Moose::Meta::Attribute::Native::Trait::String;

if (defined Moose::Meta::Attribute::Native::Trait::String->VERSION) {
	my $given_version = Moose::Meta::Attribute::Native::Trait::String->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Attribute::Native::Trait::String->VERSION . '
');

}
print("import: Moose::Meta::Class\n");
use Moose::Meta::Class;

if (defined Moose::Meta::Class->VERSION) {
	my $given_version = Moose::Meta::Class->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Class->VERSION . '
');

}
print("import: Moose::Meta::Class::Immutable::Trait\n");
use Moose::Meta::Class::Immutable::Trait;

if (defined Moose::Meta::Class::Immutable::Trait->VERSION) {
	my $given_version = Moose::Meta::Class::Immutable::Trait->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Class::Immutable::Trait->VERSION . '
');

}
print("import: Moose::Meta::Instance\n");
use Moose::Meta::Instance;

if (defined Moose::Meta::Instance->VERSION) {
	my $given_version = Moose::Meta::Instance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Instance->VERSION . '
');

}
print("import: Moose::Meta::Method\n");
use Moose::Meta::Method;

if (defined Moose::Meta::Method->VERSION) {
	my $given_version = Moose::Meta::Method->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor\n");
use Moose::Meta::Method::Accessor;

if (defined Moose::Meta::Method::Accessor->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native\n");
use Moose::Meta::Method::Accessor::Native;

if (defined Moose::Meta::Method::Accessor::Native->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array\n");
use Moose::Meta::Method::Accessor::Native::Array;

if (defined Moose::Meta::Method::Accessor::Native::Array->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::Writer\n");
use Moose::Meta::Method::Accessor::Native::Array::Writer;

if (defined Moose::Meta::Method::Accessor::Native::Array::Writer->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::Writer->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::Writer->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::accessor\n");
use Moose::Meta::Method::Accessor::Native::Array::accessor;

if (defined Moose::Meta::Method::Accessor::Native::Array::accessor->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::accessor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::accessor->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::clear\n");
use Moose::Meta::Method::Accessor::Native::Array::clear;

if (defined Moose::Meta::Method::Accessor::Native::Array::clear->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::clear->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::clear->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::count\n");
use Moose::Meta::Method::Accessor::Native::Array::count;

if (defined Moose::Meta::Method::Accessor::Native::Array::count->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::count->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::count->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::delete\n");
use Moose::Meta::Method::Accessor::Native::Array::delete;

if (defined Moose::Meta::Method::Accessor::Native::Array::delete->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::delete->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::delete->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::elements\n");
use Moose::Meta::Method::Accessor::Native::Array::elements;

if (defined Moose::Meta::Method::Accessor::Native::Array::elements->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::elements->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::elements->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::first\n");
use Moose::Meta::Method::Accessor::Native::Array::first;

if (defined Moose::Meta::Method::Accessor::Native::Array::first->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::first->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::first->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::first_index\n");
use Moose::Meta::Method::Accessor::Native::Array::first_index;

if (defined Moose::Meta::Method::Accessor::Native::Array::first_index->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::first_index->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::first_index->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::get\n");
use Moose::Meta::Method::Accessor::Native::Array::get;

if (defined Moose::Meta::Method::Accessor::Native::Array::get->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::get->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::get->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::grep\n");
use Moose::Meta::Method::Accessor::Native::Array::grep;

if (defined Moose::Meta::Method::Accessor::Native::Array::grep->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::grep->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::grep->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::insert\n");
use Moose::Meta::Method::Accessor::Native::Array::insert;

if (defined Moose::Meta::Method::Accessor::Native::Array::insert->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::insert->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::insert->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::is_empty\n");
use Moose::Meta::Method::Accessor::Native::Array::is_empty;

if (defined Moose::Meta::Method::Accessor::Native::Array::is_empty->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::is_empty->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::is_empty->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::join\n");
use Moose::Meta::Method::Accessor::Native::Array::join;

if (defined Moose::Meta::Method::Accessor::Native::Array::join->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::join->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::join->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::map\n");
use Moose::Meta::Method::Accessor::Native::Array::map;

if (defined Moose::Meta::Method::Accessor::Native::Array::map->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::map->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::map->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::natatime\n");
use Moose::Meta::Method::Accessor::Native::Array::natatime;

if (defined Moose::Meta::Method::Accessor::Native::Array::natatime->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::natatime->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::natatime->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::pop\n");
use Moose::Meta::Method::Accessor::Native::Array::pop;

if (defined Moose::Meta::Method::Accessor::Native::Array::pop->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::pop->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::pop->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::push\n");
use Moose::Meta::Method::Accessor::Native::Array::push;

if (defined Moose::Meta::Method::Accessor::Native::Array::push->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::push->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::push->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::reduce\n");
use Moose::Meta::Method::Accessor::Native::Array::reduce;

if (defined Moose::Meta::Method::Accessor::Native::Array::reduce->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::reduce->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::reduce->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::set\n");
use Moose::Meta::Method::Accessor::Native::Array::set;

if (defined Moose::Meta::Method::Accessor::Native::Array::set->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::set->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::set->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::shallow_clone\n");
use Moose::Meta::Method::Accessor::Native::Array::shallow_clone;

if (defined Moose::Meta::Method::Accessor::Native::Array::shallow_clone->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::shallow_clone->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::shallow_clone->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::shift\n");
use Moose::Meta::Method::Accessor::Native::Array::shift;

if (defined Moose::Meta::Method::Accessor::Native::Array::shift->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::shift->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::shift->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::shuffle\n");
use Moose::Meta::Method::Accessor::Native::Array::shuffle;

if (defined Moose::Meta::Method::Accessor::Native::Array::shuffle->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::shuffle->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::shuffle->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::sort\n");
use Moose::Meta::Method::Accessor::Native::Array::sort;

if (defined Moose::Meta::Method::Accessor::Native::Array::sort->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::sort->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::sort->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::sort_in_place\n");
use Moose::Meta::Method::Accessor::Native::Array::sort_in_place;

if (defined Moose::Meta::Method::Accessor::Native::Array::sort_in_place->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::sort_in_place->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::sort_in_place->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::splice\n");
use Moose::Meta::Method::Accessor::Native::Array::splice;

if (defined Moose::Meta::Method::Accessor::Native::Array::splice->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::splice->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::splice->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::uniq\n");
use Moose::Meta::Method::Accessor::Native::Array::uniq;

if (defined Moose::Meta::Method::Accessor::Native::Array::uniq->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::uniq->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::uniq->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Array::unshift\n");
use Moose::Meta::Method::Accessor::Native::Array::unshift;

if (defined Moose::Meta::Method::Accessor::Native::Array::unshift->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Array::unshift->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Array::unshift->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Bool::not\n");
use Moose::Meta::Method::Accessor::Native::Bool::not;

if (defined Moose::Meta::Method::Accessor::Native::Bool::not->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Bool::not->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Bool::not->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Bool::set\n");
use Moose::Meta::Method::Accessor::Native::Bool::set;

if (defined Moose::Meta::Method::Accessor::Native::Bool::set->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Bool::set->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Bool::set->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Bool::toggle\n");
use Moose::Meta::Method::Accessor::Native::Bool::toggle;

if (defined Moose::Meta::Method::Accessor::Native::Bool::toggle->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Bool::toggle->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Bool::toggle->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Bool::unset\n");
use Moose::Meta::Method::Accessor::Native::Bool::unset;

if (defined Moose::Meta::Method::Accessor::Native::Bool::unset->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Bool::unset->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Bool::unset->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Code::execute\n");
use Moose::Meta::Method::Accessor::Native::Code::execute;

if (defined Moose::Meta::Method::Accessor::Native::Code::execute->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Code::execute->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Code::execute->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Code::execute_method\n");
use Moose::Meta::Method::Accessor::Native::Code::execute_method;

if (defined Moose::Meta::Method::Accessor::Native::Code::execute_method->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Code::execute_method->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Code::execute_method->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Collection\n");
use Moose::Meta::Method::Accessor::Native::Collection;

if (defined Moose::Meta::Method::Accessor::Native::Collection->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Collection->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Collection->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Counter::Writer\n");
use Moose::Meta::Method::Accessor::Native::Counter::Writer;

if (defined Moose::Meta::Method::Accessor::Native::Counter::Writer->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Counter::Writer->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Counter::Writer->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Counter::dec\n");
use Moose::Meta::Method::Accessor::Native::Counter::dec;

if (defined Moose::Meta::Method::Accessor::Native::Counter::dec->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Counter::dec->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Counter::dec->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Counter::inc\n");
use Moose::Meta::Method::Accessor::Native::Counter::inc;

if (defined Moose::Meta::Method::Accessor::Native::Counter::inc->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Counter::inc->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Counter::inc->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Counter::reset\n");
use Moose::Meta::Method::Accessor::Native::Counter::reset;

if (defined Moose::Meta::Method::Accessor::Native::Counter::reset->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Counter::reset->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Counter::reset->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Counter::set\n");
use Moose::Meta::Method::Accessor::Native::Counter::set;

if (defined Moose::Meta::Method::Accessor::Native::Counter::set->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Counter::set->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Counter::set->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash\n");
use Moose::Meta::Method::Accessor::Native::Hash;

if (defined Moose::Meta::Method::Accessor::Native::Hash->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::Writer\n");
use Moose::Meta::Method::Accessor::Native::Hash::Writer;

if (defined Moose::Meta::Method::Accessor::Native::Hash::Writer->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::Writer->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::Writer->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::accessor\n");
use Moose::Meta::Method::Accessor::Native::Hash::accessor;

if (defined Moose::Meta::Method::Accessor::Native::Hash::accessor->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::accessor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::accessor->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::clear\n");
use Moose::Meta::Method::Accessor::Native::Hash::clear;

if (defined Moose::Meta::Method::Accessor::Native::Hash::clear->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::clear->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::clear->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::count\n");
use Moose::Meta::Method::Accessor::Native::Hash::count;

if (defined Moose::Meta::Method::Accessor::Native::Hash::count->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::count->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::count->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::defined\n");
use Moose::Meta::Method::Accessor::Native::Hash::defined;

if (defined Moose::Meta::Method::Accessor::Native::Hash::defined->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::defined->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::defined->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::delete\n");
use Moose::Meta::Method::Accessor::Native::Hash::delete;

if (defined Moose::Meta::Method::Accessor::Native::Hash::delete->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::delete->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::delete->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::elements\n");
use Moose::Meta::Method::Accessor::Native::Hash::elements;

if (defined Moose::Meta::Method::Accessor::Native::Hash::elements->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::elements->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::elements->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::exists\n");
use Moose::Meta::Method::Accessor::Native::Hash::exists;

if (defined Moose::Meta::Method::Accessor::Native::Hash::exists->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::exists->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::exists->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::get\n");
use Moose::Meta::Method::Accessor::Native::Hash::get;

if (defined Moose::Meta::Method::Accessor::Native::Hash::get->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::get->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::get->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::is_empty\n");
use Moose::Meta::Method::Accessor::Native::Hash::is_empty;

if (defined Moose::Meta::Method::Accessor::Native::Hash::is_empty->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::is_empty->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::is_empty->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::keys\n");
use Moose::Meta::Method::Accessor::Native::Hash::keys;

if (defined Moose::Meta::Method::Accessor::Native::Hash::keys->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::keys->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::keys->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::kv\n");
use Moose::Meta::Method::Accessor::Native::Hash::kv;

if (defined Moose::Meta::Method::Accessor::Native::Hash::kv->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::kv->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::kv->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::set\n");
use Moose::Meta::Method::Accessor::Native::Hash::set;

if (defined Moose::Meta::Method::Accessor::Native::Hash::set->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::set->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::set->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::shallow_clone\n");
use Moose::Meta::Method::Accessor::Native::Hash::shallow_clone;

if (defined Moose::Meta::Method::Accessor::Native::Hash::shallow_clone->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::shallow_clone->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::shallow_clone->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Hash::values\n");
use Moose::Meta::Method::Accessor::Native::Hash::values;

if (defined Moose::Meta::Method::Accessor::Native::Hash::values->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Hash::values->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Hash::values->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Number::abs\n");
use Moose::Meta::Method::Accessor::Native::Number::abs;

if (defined Moose::Meta::Method::Accessor::Native::Number::abs->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Number::abs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Number::abs->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Number::add\n");
use Moose::Meta::Method::Accessor::Native::Number::add;

if (defined Moose::Meta::Method::Accessor::Native::Number::add->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Number::add->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Number::add->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Number::div\n");
use Moose::Meta::Method::Accessor::Native::Number::div;

if (defined Moose::Meta::Method::Accessor::Native::Number::div->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Number::div->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Number::div->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Number::mod\n");
use Moose::Meta::Method::Accessor::Native::Number::mod;

if (defined Moose::Meta::Method::Accessor::Native::Number::mod->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Number::mod->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Number::mod->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Number::mul\n");
use Moose::Meta::Method::Accessor::Native::Number::mul;

if (defined Moose::Meta::Method::Accessor::Native::Number::mul->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Number::mul->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Number::mul->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Number::set\n");
use Moose::Meta::Method::Accessor::Native::Number::set;

if (defined Moose::Meta::Method::Accessor::Native::Number::set->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Number::set->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Number::set->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Number::sub\n");
use Moose::Meta::Method::Accessor::Native::Number::sub;

if (defined Moose::Meta::Method::Accessor::Native::Number::sub->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Number::sub->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Number::sub->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Reader\n");
use Moose::Meta::Method::Accessor::Native::Reader;

if (defined Moose::Meta::Method::Accessor::Native::Reader->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Reader->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Reader->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::append\n");
use Moose::Meta::Method::Accessor::Native::String::append;

if (defined Moose::Meta::Method::Accessor::Native::String::append->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::append->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::append->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::chomp\n");
use Moose::Meta::Method::Accessor::Native::String::chomp;

if (defined Moose::Meta::Method::Accessor::Native::String::chomp->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::chomp->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::chomp->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::chop\n");
use Moose::Meta::Method::Accessor::Native::String::chop;

if (defined Moose::Meta::Method::Accessor::Native::String::chop->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::chop->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::chop->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::clear\n");
use Moose::Meta::Method::Accessor::Native::String::clear;

if (defined Moose::Meta::Method::Accessor::Native::String::clear->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::clear->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::clear->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::inc\n");
use Moose::Meta::Method::Accessor::Native::String::inc;

if (defined Moose::Meta::Method::Accessor::Native::String::inc->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::inc->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::inc->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::length\n");
use Moose::Meta::Method::Accessor::Native::String::length;

if (defined Moose::Meta::Method::Accessor::Native::String::length->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::length->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::length->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::match\n");
use Moose::Meta::Method::Accessor::Native::String::match;

if (defined Moose::Meta::Method::Accessor::Native::String::match->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::match->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::match->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::prepend\n");
use Moose::Meta::Method::Accessor::Native::String::prepend;

if (defined Moose::Meta::Method::Accessor::Native::String::prepend->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::prepend->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::prepend->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::replace\n");
use Moose::Meta::Method::Accessor::Native::String::replace;

if (defined Moose::Meta::Method::Accessor::Native::String::replace->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::replace->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::replace->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::String::substr\n");
use Moose::Meta::Method::Accessor::Native::String::substr;

if (defined Moose::Meta::Method::Accessor::Native::String::substr->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::String::substr->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::String::substr->VERSION . '
');

}
print("import: Moose::Meta::Method::Accessor::Native::Writer\n");
use Moose::Meta::Method::Accessor::Native::Writer;

if (defined Moose::Meta::Method::Accessor::Native::Writer->VERSION) {
	my $given_version = Moose::Meta::Method::Accessor::Native::Writer->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Accessor::Native::Writer->VERSION . '
');

}
print("import: Moose::Meta::Method::Augmented\n");
use Moose::Meta::Method::Augmented;

if (defined Moose::Meta::Method::Augmented->VERSION) {
	my $given_version = Moose::Meta::Method::Augmented->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Augmented->VERSION . '
');

}
print("import: Moose::Meta::Method::Constructor\n");
use Moose::Meta::Method::Constructor;

if (defined Moose::Meta::Method::Constructor->VERSION) {
	my $given_version = Moose::Meta::Method::Constructor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Constructor->VERSION . '
');

}
print("import: Moose::Meta::Method::Delegation\n");
use Moose::Meta::Method::Delegation;

if (defined Moose::Meta::Method::Delegation->VERSION) {
	my $given_version = Moose::Meta::Method::Delegation->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Delegation->VERSION . '
');

}
print("import: Moose::Meta::Method::Destructor\n");
use Moose::Meta::Method::Destructor;

if (defined Moose::Meta::Method::Destructor->VERSION) {
	my $given_version = Moose::Meta::Method::Destructor->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Destructor->VERSION . '
');

}
print("import: Moose::Meta::Method::Meta\n");
use Moose::Meta::Method::Meta;

if (defined Moose::Meta::Method::Meta->VERSION) {
	my $given_version = Moose::Meta::Method::Meta->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Meta->VERSION . '
');

}
print("import: Moose::Meta::Method::Overridden\n");
use Moose::Meta::Method::Overridden;

if (defined Moose::Meta::Method::Overridden->VERSION) {
	my $given_version = Moose::Meta::Method::Overridden->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Method::Overridden->VERSION . '
');

}
print("import: Moose::Meta::Mixin::AttributeCore\n");
use Moose::Meta::Mixin::AttributeCore;

if (defined Moose::Meta::Mixin::AttributeCore->VERSION) {
	my $given_version = Moose::Meta::Mixin::AttributeCore->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Mixin::AttributeCore->VERSION . '
');

}
print("import: Moose::Meta::Object::Trait\n");
use Moose::Meta::Object::Trait;

if (defined Moose::Meta::Object::Trait->VERSION) {
	my $given_version = Moose::Meta::Object::Trait->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Object::Trait->VERSION . '
');

}
print("import: Moose::Meta::Role\n");
use Moose::Meta::Role;

if (defined Moose::Meta::Role->VERSION) {
	my $given_version = Moose::Meta::Role->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role->VERSION . '
');

}
print("import: Moose::Meta::Role::Application\n");
use Moose::Meta::Role::Application;

if (defined Moose::Meta::Role::Application->VERSION) {
	my $given_version = Moose::Meta::Role::Application->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Application->VERSION . '
');

}
print("import: Moose::Meta::Role::Application::RoleSummation\n");
use Moose::Meta::Role::Application::RoleSummation;

if (defined Moose::Meta::Role::Application::RoleSummation->VERSION) {
	my $given_version = Moose::Meta::Role::Application::RoleSummation->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Application::RoleSummation->VERSION . '
');

}
print("import: Moose::Meta::Role::Application::ToClass\n");
use Moose::Meta::Role::Application::ToClass;

if (defined Moose::Meta::Role::Application::ToClass->VERSION) {
	my $given_version = Moose::Meta::Role::Application::ToClass->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Application::ToClass->VERSION . '
');

}
print("import: Moose::Meta::Role::Application::ToInstance\n");
use Moose::Meta::Role::Application::ToInstance;

if (defined Moose::Meta::Role::Application::ToInstance->VERSION) {
	my $given_version = Moose::Meta::Role::Application::ToInstance->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Application::ToInstance->VERSION . '
');

}
print("import: Moose::Meta::Role::Application::ToRole\n");
use Moose::Meta::Role::Application::ToRole;

if (defined Moose::Meta::Role::Application::ToRole->VERSION) {
	my $given_version = Moose::Meta::Role::Application::ToRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Application::ToRole->VERSION . '
');

}
print("import: Moose::Meta::Role::Attribute\n");
use Moose::Meta::Role::Attribute;

if (defined Moose::Meta::Role::Attribute->VERSION) {
	my $given_version = Moose::Meta::Role::Attribute->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Attribute->VERSION . '
');

}
print("import: Moose::Meta::Role::Composite\n");
use Moose::Meta::Role::Composite;

if (defined Moose::Meta::Role::Composite->VERSION) {
	my $given_version = Moose::Meta::Role::Composite->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Composite->VERSION . '
');

}
print("import: Moose::Meta::Role::Method\n");
use Moose::Meta::Role::Method;

if (defined Moose::Meta::Role::Method->VERSION) {
	my $given_version = Moose::Meta::Role::Method->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Method->VERSION . '
');

}
print("import: Moose::Meta::Role::Method::Conflicting\n");
use Moose::Meta::Role::Method::Conflicting;

if (defined Moose::Meta::Role::Method::Conflicting->VERSION) {
	my $given_version = Moose::Meta::Role::Method::Conflicting->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Method::Conflicting->VERSION . '
');

}
print("import: Moose::Meta::Role::Method::Required\n");
use Moose::Meta::Role::Method::Required;

if (defined Moose::Meta::Role::Method::Required->VERSION) {
	my $given_version = Moose::Meta::Role::Method::Required->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::Role::Method::Required->VERSION . '
');

}
print("import: Moose::Meta::TypeCoercion\n");
use Moose::Meta::TypeCoercion;

if (defined Moose::Meta::TypeCoercion->VERSION) {
	my $given_version = Moose::Meta::TypeCoercion->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeCoercion->VERSION . '
');

}
print("import: Moose::Meta::TypeCoercion::Union\n");
use Moose::Meta::TypeCoercion::Union;

if (defined Moose::Meta::TypeCoercion::Union->VERSION) {
	my $given_version = Moose::Meta::TypeCoercion::Union->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeCoercion::Union->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint\n");
use Moose::Meta::TypeConstraint;

if (defined Moose::Meta::TypeConstraint->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::Class\n");
use Moose::Meta::TypeConstraint::Class;

if (defined Moose::Meta::TypeConstraint::Class->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::Class->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::Class->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::DuckType\n");
use Moose::Meta::TypeConstraint::DuckType;

if (defined Moose::Meta::TypeConstraint::DuckType->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::DuckType->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::DuckType->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::Enum\n");
use Moose::Meta::TypeConstraint::Enum;

if (defined Moose::Meta::TypeConstraint::Enum->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::Enum->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::Enum->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::Parameterizable\n");
use Moose::Meta::TypeConstraint::Parameterizable;

if (defined Moose::Meta::TypeConstraint::Parameterizable->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::Parameterizable->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::Parameterizable->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::Parameterized\n");
use Moose::Meta::TypeConstraint::Parameterized;

if (defined Moose::Meta::TypeConstraint::Parameterized->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::Parameterized->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::Parameterized->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::Registry\n");
use Moose::Meta::TypeConstraint::Registry;

if (defined Moose::Meta::TypeConstraint::Registry->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::Registry->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::Registry->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::Role\n");
use Moose::Meta::TypeConstraint::Role;

if (defined Moose::Meta::TypeConstraint::Role->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::Role->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::Role->VERSION . '
');

}
print("import: Moose::Meta::TypeConstraint::Union\n");
use Moose::Meta::TypeConstraint::Union;

if (defined Moose::Meta::TypeConstraint::Union->VERSION) {
	my $given_version = Moose::Meta::TypeConstraint::Union->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Meta::TypeConstraint::Union->VERSION . '
');

}
print("import: Moose::Object\n");
use Moose::Object;

if (defined Moose::Object->VERSION) {
	my $given_version = Moose::Object->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Object->VERSION . '
');

}
print("import: Moose::Util\n");
use Moose::Util;

if (defined Moose::Util->VERSION) {
	my $given_version = Moose::Util->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Util->VERSION . '
');

}
print("import: Moose::Util::MetaRole\n");
use Moose::Util::MetaRole;

if (defined Moose::Util::MetaRole->VERSION) {
	my $given_version = Moose::Util::MetaRole->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Util::MetaRole->VERSION . '
');

}
print("import: Moose::Util::TypeConstraints\n");
use Moose::Util::TypeConstraints;

if (defined Moose::Util::TypeConstraints->VERSION) {
	my $given_version = Moose::Util::TypeConstraints->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Util::TypeConstraints->VERSION . '
');

}
print("import: Moose::Util::TypeConstraints::Builtins\n");
use Moose::Util::TypeConstraints::Builtins;

if (defined Moose::Util::TypeConstraints::Builtins->VERSION) {
	my $given_version = Moose::Util::TypeConstraints::Builtins->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Moose::Util::TypeConstraints::Builtins->VERSION . '
');

}
