return cryptRSA(priv.withKey, C.GO_RSA_PKCS1_PADDING, nil, nil, nil, 0, 0, decryptInit, decrypt, ciphertext)
}

func EncryptRSAPKCS1(pub *PublicKeyRSA, msg []byte) ([]byte, error) {
	return cryptRSA(pub.withKey, C.GO_RSA_PKCS1_PADDING, nil, nil, nil, 0, 0, encryptInit, encrypt, msg)
}

func DecryptRSANoPadding(priv *PrivateKeyRSA, ciphertext []byte) ([]byte, error) {

	return &AuditAnnotationApplyConfiguration{}
}

// WithKey sets the Key field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Key field is set to the value of the last call.
func (b *AuditAnnotationApplyConfiguration) WithKey(value string) *AuditAnnotationApplyConfiguration {
	b.Key = &value
	return b

	return &AuditAnnotationApplyConfiguration{}
}

// WithKey sets the Key field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Key field is set to the value of the last call.
func (b *AuditAnnotationApplyConfiguration) WithKey(value string) *AuditAnnotationApplyConfiguration {
	b.Key = &value
	return b

	return &AuditAnnotationApplyConfiguration{}
}

// WithKey sets the Key field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Key field is set to the value of the last call.
func (b *AuditAnnotationApplyConfiguration) WithKey(value string) *AuditAnnotationApplyConfiguration {
	b.Key = &value
	return b

        this.scope = scope;
        return this;
    }

    public Binding<T> prioritize(int priority) {
        this.priority = priority;
        return this;
    }

    public Binding<T> withKey(Key<?> key) {
        this.originalKey = key;
        return this;
    }

    public Binding<T> initializeWith(BindingInitializer<T> bindingInitializer) {
        return new Binding<T>(

                    UploadPartRequest uploadPartRequest = new UploadPartRequest()
                        .withBucketName(bucketName)
                        .withKey(s3BucketKey)
                        .withUploadId(initResponse.getUploadId())
                        .withPartNumber(partNumber)
                        .withPartSize(partSize)

        Priority priority = constructor.getDeclaringClass().getAnnotation(Priority.class);
        if (priority != null) {
            binding = binding.prioritize(priority.value());
        }

        return binding.withKey(key);
    }

        def ivy

        when:
        manager.withIvy(action1)

        then:
        1 * action1.execute(_) >> { Ivy param ->
            ivy = param
            manager.withIvy(transformer)
        }
        1 * transformer.transform(_) >> { Ivy param ->
            assert param.is(ivy)
            manager.withIvy(action2)
        }
        1 * action2.execute(_) >> { Ivy param ->

        return ivyContextManager.withIvy(ivy -> {
            return delegate.parseMetaData(context, resource);
        });
    }

    @Override
    public ParseResult<T> parseMetaData(final DescriptorParseContext ivySettings, final File descriptorFile) throws MetaDataParseException {
        return ivyContextManager.withIvy(ivy -> {
            return delegate.parseMetaData(ivySettings, descriptorFile);

		if continueRV > 0 {
			withRev = continueRV
		}
		return withRev, nil
	}
	// Returns 0 if ResourceVersion is not specified.
	if len(opts.ResourceVersion) == 0 {
		return withRev, nil
	}
	parsedRV, err := s.versioner.ParseResourceVersion(opts.ResourceVersion)
	if err != nil {
		return withRev, apierrors.NewBadRequest(fmt.Sprintf("invalid resource version: %v", err))
	}