text:
package azblob

// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
	"context"
	"encoding/base64"
	"github.com/Azure/azure-pipeline-go/pipeline"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

// blobsClient is the client for the Blobs methods of the Azblob service.
type blobsClient struct {
	managementClient
}

// newBlobsClient creates an instance of the blobsClient client.
func newBlobsClient(url url.URL, p pipeline.Pipeline) blobsClient {
	return blobsClient{newManagementClient(url, p)}
}

// AbortCopyFromURL the Abort Copy From URL operation aborts a pending Copy From URL operation, and leaves a
// destination blob with zero length and full metadata.
//
// copyID is the copy identifier provided in the x-ms-copy-id header of the original Copy Blob operation. timeout is
// the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. leaseID is if specified, the operation only succeeds if the container's
// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
// limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) AbortCopyFromURL(ctx context.Context, copyID string, timeout *int32, leaseID *string, requestID *string) (*BlobsAbortCopyFromURLResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.abortCopyFromURLPreparer(copyID, timeout, leaseID, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.abortCopyFromURLResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsAbortCopyFromURLResponse), err
}

// abortCopyFromURLPreparer prepares the AbortCopyFromURL request.
func (client blobsClient) abortCopyFromURLPreparer(copyID string, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	params.Set("copyid", copyID)
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "copy")
	req.URL.RawQuery = params.Encode()
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	req.Header.Set("x-ms-copy-action", "abort")
	return req, nil
}

// abortCopyFromURLResponder handles the response to the AbortCopyFromURL request.
func (client blobsClient) abortCopyFromURLResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusNoContent)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsAbortCopyFromURLResponse{rawResponse: resp.Response()}, err
}

// AcquireLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. duration is specifies the duration of the lease, in seconds, or negative
// one (-1) for a lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease duration
// cannot be changed using renew or change. proposedLeaseID is proposed lease ID, in a GUID string format. The Blob
// service returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid Constructor
// (String) for a list of valid GUID string formats. ifModifiedSince is specify this header value to operate only on a
// blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
// recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) AcquireLease(ctx context.Context, timeout *int32, duration *int32, proposedLeaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsAcquireLeaseResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.acquireLeasePreparer(timeout, duration, proposedLeaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.acquireLeaseResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsAcquireLeaseResponse), err
}

// acquireLeasePreparer prepares the AcquireLease request.
func (client blobsClient) acquireLeasePreparer(timeout *int32, duration *int32, proposedLeaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "lease")
	req.URL.RawQuery = params.Encode()
	if duration != nil {
		req.Header.Set("x-ms-lease-duration", strconv.FormatInt(int64(*duration), 10))
	}
	if proposedLeaseID != nil {
		req.Header.Set("x-ms-proposed-lease-id", *proposedLeaseID)
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	req.Header.Set("x-ms-lease-action", "acquire")
	return req, nil
}

// acquireLeaseResponder handles the response to the AcquireLease request.
func (client blobsClient) acquireLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsAcquireLeaseResponse{rawResponse: resp.Response()}, err
}

// BreakLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. breakPeriod is for a break operation, proposed duration the lease should
// continue before it is broken, in seconds, between 0 and 60. This break period is only used if it is shorter than the
// time remaining on the lease. If longer, the time remaining on the lease is used. A new lease will not be available
// before the break period has expired, but the lease may be held for longer than the break period. If this header does
// not appear with a break operation, a fixed-duration lease breaks after the remaining lease period elapses, and an
// infinite lease breaks immediately. ifModifiedSince is specify this header value to operate only on a blob if it has
// been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
// analytics logs when storage analytics logging is enabled.
func (client blobsClient) BreakLease(ctx context.Context, timeout *int32, breakPeriod *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsBreakLeaseResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.breakLeasePreparer(timeout, breakPeriod, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.breakLeaseResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsBreakLeaseResponse), err
}

// breakLeasePreparer prepares the BreakLease request.
func (client blobsClient) breakLeasePreparer(timeout *int32, breakPeriod *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "lease")
	req.URL.RawQuery = params.Encode()
	if breakPeriod != nil {
		req.Header.Set("x-ms-lease-break-period", strconv.FormatInt(int64(*breakPeriod), 10))
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	req.Header.Set("x-ms-lease-action", "break")
	return req, nil
}

// breakLeaseResponder handles the response to the BreakLease request.
func (client blobsClient) breakLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsBreakLeaseResponse{rawResponse: resp.Response()}, err
}

// ChangeLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
// proposedLeaseID is proposed lease ID, in a GUID string format. The Blob service returns 400 (Invalid request) if the
// proposed lease ID is not in the correct format. See Guid Constructor (String) for a list of valid GUID string
// formats. timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. ifModifiedSince is specify this header value to operate only on a blob if
// it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only
// on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate
// only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
// in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) ChangeLease(ctx context.Context, leaseID string, proposedLeaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsChangeLeaseResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.changeLeasePreparer(leaseID, proposedLeaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.changeLeaseResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsChangeLeaseResponse), err
}

// changeLeasePreparer prepares the ChangeLease request.
func (client blobsClient) changeLeasePreparer(leaseID string, proposedLeaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "lease")
	req.URL.RawQuery = params.Encode()
	req.Header.Set("x-ms-lease-id", leaseID)
	req.Header.Set("x-ms-proposed-lease-id", proposedLeaseID)
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	req.Header.Set("x-ms-lease-action", "change")
	return req, nil
}

// changeLeaseResponder handles the response to the ChangeLease request.
func (client blobsClient) changeLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsChangeLeaseResponse{rawResponse: resp.Response()}, err
}

// CreateSnapshot the Create Snapshot operation creates a read-only snapshot of a blob
//
// timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. metadata is optional. Specifies a user-defined name-value pair associated
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
// Containers, Blobs, and Metadata for more information. ifModifiedSince is specify this header value to operate only
// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. leaseID is if specified, the operation only succeeds if the container's lease is active
// and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
// recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) CreateSnapshot(ctx context.Context, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, requestID *string) (*BlobsCreateSnapshotResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
		{targetValue: metadata,
			constraints: []constraint{{target: "metadata", name: null, rule: false,
				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.createSnapshotPreparer(timeout, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, leaseID, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createSnapshotResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsCreateSnapshotResponse), err
}

// createSnapshotPreparer prepares the CreateSnapshot request.
func (client blobsClient) createSnapshotPreparer(timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "snapshot")
	req.URL.RawQuery = params.Encode()
	if metadata != nil {
		for k, v := range metadata {
			req.Header.Set("x-ms-meta-"+k, v)
		}
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// createSnapshotResponder handles the response to the CreateSnapshot request.
func (client blobsClient) createSnapshotResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsCreateSnapshotResponse{rawResponse: resp.Response()}, err
}

// Delete if the storage account's soft delete feature is disabled then, when a blob is deleted, it is permanently
// removed from the storage account. If the storage account's soft delete feature is enabled, then, when a blob is
// deleted, it is marked for deletion and becomes inaccessible immediately. However, the blob service retains the blob
// or snapshot for the number of days specified by the DeleteRetentionPolicy section of [Storage service properties]
// (Set-Blob-Service-Properties.md). After the specified number of days has passed, the blob's data is permanently
// removed from the storage account. Note that you continue to be charged for the soft-deleted blob's storage until it
// is permanently removed. Use the List Blobs API and specify the "include=deleted" query parameter to discover which
// blobs and snapshots have been soft deleted. You can then use the Undelete Blob API to restore a soft-deleted blob.
// All other operations on a soft-deleted blob or snapshot causes the service to return an HTTP status code of 404
// (ResourceNotFound).
//
// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
// retrieve. For more information on working with blob snapshots, see Creating
// a Snapshot of a Blob. timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. leaseID is if specified, the operation only succeeds if the container's
// lease is active and matches this ID. deleteSnapshots is required if the blob has associated snapshots. Specify one
// of the following two options: include: Delete the base blob and all of its snapshots. only: Delete only the blob's
// snapshots and not the blob itself ifModifiedSince is specify this header value to operate only on a blob if it has
// been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
// analytics logs when storage analytics logging is enabled.
func (client blobsClient) Delete(ctx context.Context, snapshot *string, timeout *int32, leaseID *string, deleteSnapshots DeleteSnapshotsOptionType, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsDeleteResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.deletePreparer(snapshot, timeout, leaseID, deleteSnapshots, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.deleteResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsDeleteResponse), err
}

// deletePreparer prepares the Delete request.
func (client blobsClient) deletePreparer(snapshot *string, timeout *int32, leaseID *string, deleteSnapshots DeleteSnapshotsOptionType, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("DELETE", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if snapshot != nil && len(*snapshot) > 0 {
		params.Set("snapshot", *snapshot)
	}
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	req.URL.RawQuery = params.Encode()
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	if deleteSnapshots != DeleteSnapshotsOptionNone {
		req.Header.Set("x-ms-delete-snapshots", string(deleteSnapshots))
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// deleteResponder handles the response to the Delete request.
func (client blobsClient) deleteResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsDeleteResponse{rawResponse: resp.Response()}, err
}

// Download the Download operation reads or downloads a blob from the system, including its metadata and properties.
// You can also call Download to read a snapshot.
//
// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
// retrieve. For more information on working with blob snapshots, see Creating
// a Snapshot of a Blob. timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. rangeParameter is return only the bytes of the blob in the specified
// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
// rangeGetContentMD5 is when set to true and specified together with the Range, the service returns the MD5 hash for
// the range, as long as the range is less than or equal to 4 MB in size. ifModifiedSince is specify this header value
// to operate only on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this
// header value to operate only on a blob if it has not been modified since the specified date/time. ifMatches is
// specify an ETag value to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to
// operate only on blobs without a matching value. requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) Download(ctx context.Context, snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, rangeGetContentMD5 *bool, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*downloadResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.downloadPreparer(snapshot, timeout, rangeParameter, leaseID, rangeGetContentMD5, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.downloadResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*downloadResponse), err
}

// downloadPreparer prepares the Download request.
func (client blobsClient) downloadPreparer(snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, rangeGetContentMD5 *bool, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("GET", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if snapshot != nil && len(*snapshot) > 0 {
		params.Set("snapshot", *snapshot)
	}
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	req.URL.RawQuery = params.Encode()
	if rangeParameter != nil {
		req.Header.Set("x-ms-range", *rangeParameter)
	}
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	if rangeGetContentMD5 != nil {
		req.Header.Set("x-ms-range-get-content-md5", strconv.FormatBool(*rangeGetContentMD5))
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// downloadResponder handles the response to the Download request.
func (client blobsClient) downloadResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusPartialContent)
	if resp == nil {
		return nil, err
	}
	return &downloadResponse{rawResponse: resp.Response()}, err
}

// GetProperties the Get Properties operation returns all user-defined metadata, standard HTTP properties, and system
// properties for the blob. It does not return the content of the blob.
//
// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
// retrieve. For more information on working with blob snapshots, see Creating
// a Snapshot of a Blob. timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. leaseID is if specified, the operation only succeeds if the container's
// lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it
// has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
// analytics logs when storage analytics logging is enabled.
func (client blobsClient) GetProperties(ctx context.Context, snapshot *string, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsGetPropertiesResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.getPropertiesPreparer(snapshot, timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getPropertiesResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsGetPropertiesResponse), err
}

// getPropertiesPreparer prepares the GetProperties request.
func (client blobsClient) getPropertiesPreparer(snapshot *string, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("HEAD", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if snapshot != nil && len(*snapshot) > 0 {
		params.Set("snapshot", *snapshot)
	}
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	req.URL.RawQuery = params.Encode()
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// getPropertiesResponder handles the response to the GetProperties request.
func (client blobsClient) getPropertiesResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsGetPropertiesResponse{rawResponse: resp.Response()}, err
}

// ReleaseLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID. timeout
// is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. ifModifiedSince is specify this header value to operate only on a blob if
// it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only
// on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate
// only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
// in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) ReleaseLease(ctx context.Context, leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsReleaseLeaseResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.releaseLeasePreparer(leaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.releaseLeaseResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsReleaseLeaseResponse), err
}

// releaseLeasePreparer prepares the ReleaseLease request.
func (client blobsClient) releaseLeasePreparer(leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "lease")
	req.URL.RawQuery = params.Encode()
	req.Header.Set("x-ms-lease-id", leaseID)
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	req.Header.Set("x-ms-lease-action", "release")
	return req, nil
}

// releaseLeaseResponder handles the response to the ReleaseLease request.
func (client blobsClient) releaseLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsReleaseLeaseResponse{rawResponse: resp.Response()}, err
}

// RenewLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID. timeout
// is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. ifModifiedSince is specify this header value to operate only on a blob if
// it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only
// on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate
// only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
// in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) RenewLease(ctx context.Context, leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsRenewLeaseResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.renewLeasePreparer(leaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.renewLeaseResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsRenewLeaseResponse), err
}

// renewLeasePreparer prepares the RenewLease request.
func (client blobsClient) renewLeasePreparer(leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "lease")
	req.URL.RawQuery = params.Encode()
	req.Header.Set("x-ms-lease-id", leaseID)
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	req.Header.Set("x-ms-lease-action", "renew")
	return req, nil
}

// renewLeaseResponder handles the response to the RenewLease request.
func (client blobsClient) renewLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsRenewLeaseResponse{rawResponse: resp.Response()}, err
}

// SetHTTPHeaders the Set HTTP Headers operation sets system properties on the blob
//
// timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. blobCacheControl is optional. Sets the blob's cache control. If specified,
// this property is stored with the blob and returned with a read request. blobContentType is optional. Sets the blob's
// content type. If specified, this property is stored with the blob and returned with a read request. blobContentMD5
// is optional. An MD5 hash of the blob content. Note that this hash is not validated, as the hashes for the individual
// blocks were validated when each was uploaded. blobContentEncoding is optional. Sets the blob's content encoding. If
// specified, this property is stored with the blob and returned with a read request. blobContentLanguage is optional.
// Set the blob's content language. If specified, this property is stored with the blob and returned with a read
// request. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this
// ID. ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the
// specified date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been
// modified since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching
// value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching value.
// blobContentDisposition is optional. Sets the blob's Content-Disposition header. requestID is provides a
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
// analytics logging is enabled.
func (client blobsClient) SetHTTPHeaders(ctx context.Context, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentMD5 []byte, blobContentEncoding *string, blobContentLanguage *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentDisposition *string, requestID *string) (*BlobsSetHTTPHeadersResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.setHTTPHeadersPreparer(timeout, blobCacheControl, blobContentType, blobContentMD5, blobContentEncoding, blobContentLanguage, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, blobContentDisposition, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setHTTPHeadersResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsSetHTTPHeadersResponse), err
}

// setHTTPHeadersPreparer prepares the SetHTTPHeaders request.
func (client blobsClient) setHTTPHeadersPreparer(timeout *int32, blobCacheControl *string, blobContentType *string, blobContentMD5 []byte, blobContentEncoding *string, blobContentLanguage *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentDisposition *string, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "properties")
	req.URL.RawQuery = params.Encode()
	if blobCacheControl != nil {
		req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
	}
	if blobContentType != nil {
		req.Header.Set("x-ms-blob-content-type", *blobContentType)
	}
	if blobContentMD5 != nil {
		req.Header.Set("x-ms-blob-content-md5", base64.StdEncoding.EncodeToString(blobContentMD5))
	}
	if blobContentEncoding != nil {
		req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
	}
	if blobContentLanguage != nil {
		req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
	}
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	if blobContentDisposition != nil {
		req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// setHTTPHeadersResponder handles the response to the SetHTTPHeaders request.
func (client blobsClient) setHTTPHeadersResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsSetHTTPHeadersResponse{rawResponse: resp.Response()}, err
}

// SetMetadata the Set Blob Metadata operation sets user-defined metadata for the specified blob as one or more
// name-value pairs
//
// timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. metadata is optional. Specifies a user-defined name-value pair associated
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
// Containers, Blobs, and Metadata for more information. leaseID is if specified, the operation only succeeds if the
// container's lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a
// blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
// recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) SetMetadata(ctx context.Context, timeout *int32, metadata map[string]string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobsSetMetadataResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
		{targetValue: metadata,
			constraints: []constraint{{target: "metadata", name: null, rule: false,
				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.setMetadataPreparer(timeout, metadata, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setMetadataResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsSetMetadataResponse), err
}

// setMetadataPreparer prepares the SetMetadata request.
func (client blobsClient) setMetadataPreparer(timeout *int32, metadata map[string]string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "metadata")
	req.URL.RawQuery = params.Encode()
	if metadata != nil {
		for k, v := range metadata {
			req.Header.Set("x-ms-meta-"+k, v)
		}
	}
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// setMetadataResponder handles the response to the SetMetadata request.
func (client blobsClient) setMetadataResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsSetMetadataResponse{rawResponse: resp.Response()}, err
}

// SetTier the Set Tier operation sets the tier on a blob. The operation is allowed on a page blob in a premium storage
// account and on a block blob in a blob storage account (locally redundant storage only). A premium page blob's tier
// determines the allowed size, IOPS, and bandwidth of the blob. A block blob's tier determines Hot/Cool/Archive
// storage type. This operation does not update the blob's ETag.
//
// tier is indicates the tier to be set on the blob. timeout is the timeout parameter is expressed in seconds. For more
// information, see Setting
// Timeouts for Blob Service Operations. requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) SetTier(ctx context.Context, tier AccessTierType, timeout *int32, requestID *string) (*BlobsSetTierResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.setTierPreparer(tier, timeout, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setTierResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsSetTierResponse), err
}

// setTierPreparer prepares the SetTier request.
func (client blobsClient) setTierPreparer(tier AccessTierType, timeout *int32, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "tier")
	req.URL.RawQuery = params.Encode()
	req.Header.Set("x-ms-access-tier", string(tier))
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// setTierResponder handles the response to the SetTier request.
func (client blobsClient) setTierResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsSetTierResponse{rawResponse: resp.Response()}, err
}

// StartCopyFromURL the Start Copy From URL operation copies a blob or an internet resource to a new blob.
//
// copySource is specifies the name of the source page blob snapshot. This value is a URL of up to 2 KB in length that
// specifies a page blob snapshot. The value should be URL-encoded as it would appear in a request URI. The source blob
// must either be public or must be authenticated via a shared access signature. timeout is the timeout parameter is
// expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. metadata is optional. Specifies a user-defined name-value pair associated
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
// Containers, Blobs, and Metadata for more information. sourceIfModifiedSince is specify this header value to operate
// only on a blob if it has been modified since the specified date/time. sourceIfUnmodifiedSince is specify this header
// value to operate only on a blob if it has not been modified since the specified date/time. sourceIfMatches is
// specify an ETag value to operate only on blobs with a matching value. sourceIfNoneMatch is specify an ETag value to
// operate only on blobs without a matching value. ifModifiedSince is specify this header value to operate only on a
// blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. leaseID is if specified, the operation only succeeds if the container's lease is active
// and matches this ID. sourceLeaseID is specify this header to perform the operation only if the lease ID given
// matches the active lease ID of the source blob. requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) StartCopyFromURL(ctx context.Context, copySource string, timeout *int32, metadata map[string]string, sourceIfModifiedSince *time.Time, sourceIfUnmodifiedSince *time.Time, sourceIfMatches *ETag, sourceIfNoneMatch *ETag, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, sourceLeaseID *string, requestID *string) (*BlobsStartCopyFromURLResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
		{targetValue: metadata,
			constraints: []constraint{{target: "metadata", name: null, rule: false,
				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.startCopyFromURLPreparer(copySource, timeout, metadata, sourceIfModifiedSince, sourceIfUnmodifiedSince, sourceIfMatches, sourceIfNoneMatch, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, leaseID, sourceLeaseID, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.startCopyFromURLResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsStartCopyFromURLResponse), err
}

// startCopyFromURLPreparer prepares the StartCopyFromURL request.
func (client blobsClient) startCopyFromURLPreparer(copySource string, timeout *int32, metadata map[string]string, sourceIfModifiedSince *time.Time, sourceIfUnmodifiedSince *time.Time, sourceIfMatches *ETag, sourceIfNoneMatch *ETag, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, sourceLeaseID *string, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	req.URL.RawQuery = params.Encode()
	if metadata != nil {
		for k, v := range metadata {
			req.Header.Set("x-ms-meta-"+k, v)
		}
	}
	if sourceIfModifiedSince != nil {
		req.Header.Set("x-ms-source-if-modified-since", (*sourceIfModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if sourceIfUnmodifiedSince != nil {
		req.Header.Set("x-ms-source-if-unmodified-since", (*sourceIfUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if sourceIfMatches != nil {
		req.Header.Set("x-ms-source-if-match", string(*sourceIfMatches))
	}
	if sourceIfNoneMatch != nil {
		req.Header.Set("x-ms-source-if-none-match", string(*sourceIfNoneMatch))
	}
	if ifModifiedSince != nil {
		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifUnmodifiedSince != nil {
		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
	}
	if ifMatches != nil {
		req.Header.Set("If-Match", string(*ifMatches))
	}
	if ifNoneMatch != nil {
		req.Header.Set("If-None-Match", string(*ifNoneMatch))
	}
	req.Header.Set("x-ms-copy-source", copySource)
	if leaseID != nil {
		req.Header.Set("x-ms-lease-id", *leaseID)
	}
	if sourceLeaseID != nil {
		req.Header.Set("x-ms-source-lease-id", *sourceLeaseID)
	}
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// startCopyFromURLResponder handles the response to the StartCopyFromURL request.
func (client blobsClient) startCopyFromURLResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsStartCopyFromURLResponse{rawResponse: resp.Response()}, err
}

// Undelete undelete a blob that was previously soft deleted
//
// timeout is the timeout parameter is expressed in seconds. For more information, see Setting
// Timeouts for Blob Service Operations. requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobsClient) Undelete(ctx context.Context, timeout *int32, requestID *string) (*BlobsUndeleteResponse, error) {
	if err := validate([]validation{
		{targetValue: timeout,
			constraints: []constraint{{target: "timeout", name: null, rule: false,
				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
		return nil, err
	}
	req, err := client.undeletePreparer(timeout, requestID)
	if err != nil {
		return nil, err
	}
	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.undeleteResponder}, req)
	if err != nil {
		return nil, err
	}
	return resp.(*BlobsUndeleteResponse), err
}

// undeletePreparer prepares the Undelete request.
func (client blobsClient) undeletePreparer(timeout *int32, requestID *string) (pipeline.Request, error) {
	req, err := pipeline.NewRequest("PUT", client.url, nil)
	if err != nil {
		return req, pipeline.NewError(err, "failed to create request")
	}
	params := req.URL.Query()
	if timeout != nil {
		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
	}
	params.Set("comp", "undelete")
	req.URL.RawQuery = params.Encode()
	req.Header.Set("x-ms-version", ServiceVersion)
	if requestID != nil {
		req.Header.Set("x-ms-client-request-id", *requestID)
	}
	return req, nil
}

// undeleteResponder handles the response to the Undelete request.
func (client blobsClient) undeleteResponder(resp pipeline.Response) (pipeline.Response, error) {
	err := validateResponse(resp, http.StatusOK)
	if resp == nil {
		return nil, err
	}
	io.Copy(ioutil.Discard, resp.Response().Body)
	resp.Response().Body.Close()
	return &BlobsUndeleteResponse{rawResponse: resp.Response()}, err
}


text:
package net.alexhicks.apcs.game;

public enum Direction {

	UP, DOWN, LEFT, RIGHT;
}

redpajama_set_name: RedPajamaGithub


text:
from __future__ import division, print_function, absolute_import
__author__ = 'jiajunshen'
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('model', metavar='<parts net file>', type=argparse.FileType('wb'), help='Filename of model file')
parser.add_argument('--log', action='store_true')

args = parser.parse_args()

if args.log:
    from pnet.vzlog import default as vz

import numpy as np
import amitgroup as ag
import sys
ag.set_verbose(True)

from pnet.bernoullimm import BernoulliMM
import pnet
from sklearn.svm import LinearSVC

#net_pretrain = pnet.PartsNet.load("./test_360_scaled.npy")

print("before train")
layers = [
    pnet.NormalizeLayer(),
    #pnet.IntensityThresholdLayer(),

    #pnet.OrientedGaussianPartsLayer(32,1,(5,5),settings=dict(
    #    seed=0,
    #   n_init = 2,
    #    samples_per_image=10,
    #    max_samples=200000,
    #    channel_mode='together',
    #    coding="soft"
    #    #covariance_type = ''
    #)),
    #pnet.MaxPoolingLayer(shape=(2,2), strides=(2, 2)),

    pnet.RandomPartitionSVMLayer(num_parts=360, part_shape=(3,3),settings=dict(outer_frame=2,
                                                                                threshold = 0,
                                                                                samples_per_image=10,
                                                                                max_samples=500000,
                                                                                patch_extraction_seed = 17389,
                                                                                all_locations = False,
                                                                                use_theano = True,
                                                                                random_seeds = 17389
    )),
    #pnet.EdgeLayer(k=5, radius=1, spread='orthogonal', minimum_contrast=0.05),
    #pnet.IntensityThresholdLayer(),
    #pnet.PartsLayer(100, (6, 6), settings=dict(outer_frame=0,
    #                                          threshold=40,
    #                                          samples_per_image=50,
    #                                          max_samples=5000,
    #                                          min_prob=0.005,
    #                                          )),
    pnet.MaxPoolingLayer(shape=(2,2), strides=(2, 2)),
    pnet.RandomPartitionSVMLayer(num_parts=360, part_shape=(3,3),settings=dict(outer_frame=2,
                                                                                threshold = 0,
                                                                                samples_per_image=30,
                                                                                max_samples=100000,
                                                                                patch_extraction_seed = 37813,
                                                                                all_locations = False,
                                                                                use_theano = True,
                                                                                random_seeds = 37813
    )),
    pnet.MaxPoolingLayer(shape=(2,2), strides=(2, 2)),
    pnet.RandomPartitionSVMLayer(num_parts=360, part_shape=(3,3),settings=dict(outer_frame=2,
                                                                                threshold = 0,
                                                                                samples_per_image=30,
                                                                                max_samples=100000,
                                                                                patch_extraction_seed = 59359,
                                                                                all_locations = False,
                                                                                random_seeds = 59359
    )),
    pnet.MaxPoolingLayer(shape=(2,2), strides=(2, 2)),
    #pnet.MixtureClassificationLayer(n_components=1, min_prob=0.0001,block_size=200)
    pnet.SVMClassificationLayer(C=0.001)
]

#layers = net_pretrain.layers[:7]

#layers += [pnet.SGDSVMClassificationLayer()]

net = pnet.PartsNet(layers)

digits = range(10)
#ims = ag.io.load_mnist('training', selection=slice(10000), return_labels=False)
#label = None
ims,label = ag.io.load_cifar10('training', selection=slice(5000))

#print(net.sizes(X[[0]]))
print("start train")
net.train(ims,label)

"""
sup_ims = []
sup_labels = []
# Load supervised training data
for d in digits:
    ims0 = ag.io.load_mnist('training', [d], selection=slice(10), return_labels=False)
    sup_ims.append(ims0)
    sup_labels.append(d * np.ones(len(ims0), dtype=np.int64))

sup_ims = np.concatenate(sup_ims, axis=0)
sup_labels = np.concatenate(sup_labels, axis=0)

net.train(sup_ims, sup_labels)
"""

net.save(args.model)

if args.log:
    net.infoplot(vz)
    vz.finalize()


text:
**Add remote repository:**

~~~~
git remote add <remote-name> <remote-url>
~~~~

Example:

- Add upstream remote:

    ~~~~
    git remote add upstream <REMOTE-URL>
    ~~~~

Show all remotes and their urls:

~~~~
git remote -v
~~~~


text:
div.sheet-tab-content {
      display: none;
    }
    input.sheet-tab1:checked ~ div.sheet-tab1, input.sheet-tab2:checked ~ div.sheet-tab2, input.sheet-tab3:checked ~ div.sheet-tab3, input.sheet-tab4:checked ~ div.sheet-tab4, input.sheet-tab5:checked ~ div.sheet-tab5, input.sheet-tab6:checked ~ div.sheet-tab6 {
      display: block;
    }
    input.sheet-tab {
      width: 120px;
      height: 20px;
      top: 5px;
      left: 6px;
      margin: -1.5px;
      cursor: pointer;
      z-index: 1;
      position: relative;
      border-radius: 10px;
    }
    input.sheet-tab::before {
      content: attr(title);
      border-width: 1px;
      border-style: solid;
      border-color: rgb(168, 168, 168) rgb(168, 168, 168) black;
      text-align: center;
      display: inline-block;
      width: 120px;
      height: 20px;
      font-size: 16px;
      border-radius: 10px;
      top: 96px;
      background: rgb(255, 255, 255);
    }
    input.sheet-tab:checked::before {
      border-radius: 10px;
      background: rgb(220, 220, 220);
    }
    div.sheet-tab-content {
      padding: 4px 0px;
      width: 840px;
      margin: 16px 0px;
      position: relative;
      min-height: 360px;
      background-color: white;
    }
    .sheet-wrapper {
      position: absolute;
      width: 840px;
      height: 840px;
      left: 0px;
      top: 0px;
      font-family: arial;
      font-size: 12px;
      border-image-source: none;
      border-color: transparent;
      background-image: none;
      background-color: rgb(187, 187, 187);
    }
    .sheet-attrbox-div {
      position: absolute;
      font-family: arial;
      font-size: 12px;
      border-image-source: none;
      border-color: transparent;
      border-radius: 8px;
      transform-origin: 89px 62.5px 0px;
      background-image: none;
      background-color: rgb(187, 187, 187);
    }
    .sheet-attrbox-label {
      position: absolute;
      display: inline;
      font-family: Arial;
      font-size: 12px;
      font-weight: bold;
      text-align: right;
      padding: 0px;
      margin: 0px;
    }
    .sheet-attrbox-points-input {
      position: absolute;
      text-align: center;
      border-radius: 8px;
      padding: 0px;
      margin: 0px;
      font-family: arial;
      font-size: 12px;
      border: none;
      font-weight: bolder;
    }
    .sheet-attrbox-points-select {
      position: absolute;
      text-align: center;
      text-align-last: center;
      border-radius: 8px;
      font-family: arial;
      font-size: 12px;
      border: none;
      -webkit-appearance: none;
      text-indent: 1px;
      font-weight: normal;
      padding: 0px !important;
      margin: 0px !important;
      line-height: 16px !important;
    }
    input[type="number"]::-webkit-inner-spin-button, input[type="number"]::-webkit-outer-spin-button {
      -webkit-appearance: none;
      margin: 0px;
    }
    .sheet-rollbox {
      position: absolute;
      height: 16px;
      margin: 0px;
      padding: 0px;
      border-radius: 8px;
      width: 76px;
      border: none;
      background-image: none;
      background-color: rgb(255, 255, 255);
    }
    .sheet-rollbox-input {
      position: absolute;
      height: 14px;
      border-style: none;
      padding: 0px;
      margin: 0px;
      font-family: arial;
      font-size: 12px;
      width: 20px;
      border-image-source: none;
      border-color: transparent;
      font-weight: normal;
      background-color: transparent;
    }
    .sheet-rollbox-span {
      position: absolute;
      height: 14px;
      width: 14px;
      font-size: 12px;
      font-family: arial;
      padding: 0px;
      margin: 0px;
      font-weight: normal;
    }
    .sheet-rollbox-rollbutton {
      border-radius: 7px;
      cursor: pointer;
      color: rgb(255, 255, 255);
      position: absolute;
      padding: 5px;
      border: 1px solid rgb(216, 53, 38);
      width: 14px;
      height: 14px;
      background: none rgb(252, 141, 131);
    }
    .sheet-rollbox-rollbutton:hover {
      background: linear-gradient(rgb(228, 104, 93) 5%, rgb(252, 141, 131) 100%) rgb(228, 104, 93);
    }
    .sheet-rollbox-rollbutton:active {
      position: absolute;
      transform: translate(0px, 1px);
    }
    button[type="roll"]::before {
      font-size: 0.75em;
      display: none;
      content: "" !important;
    }
    div.sheet-tab-entity-content {
      display: none;
    }
    input.sheet-tab-entity1:checked ~ div.sheet-tab-entity1, input.sheet-tab-entity2:checked ~ div.sheet-tab-entity2, input.sheet-tab-entity3:checked ~ div.sheet-tab-entity3, input.sheet-tab-entity4:checked ~ div.sheet-tab-entity4 {
      display: block;
    }
    input.sheet-tab-entity {
      width: 1px;
      height: 1px;
      top: 0px;
      left: 0px;
      line-height: 0px;
      opacity: 0;
      cursor: pointer;
      position: absolute;
    }
    div.sheet-tab-entity-content {
      min-height: 360px;
      position: relative;
    }
    .sheet-attrbox-column {
      font-size: 10px;
      color: rgb(80, 80, 80);
      text-align: center;
    }
    .sheet-luck-container {
      font-family: Arial;
      font-size: 16px;
      position: absolute;
      width: 92px;
      top: 98px;
      left: 82px;
      height: 38px;
      background-image: url("https://cdn.rawgit.com/FieryScubaDivingAccident/1d7d61225d6082983ff8603e32a2d763/raw/eb3aff794907fea5cd5f417bc1c847dfdcdc7d35/eaba_luck_numbers.svg");
      background-size: 92px 38px;
      background-repeat: no-repeat;
    }
    .sheet-luckbox {
      font-family: Arial;
      font-size: 12px;
    }
    .sheet-lucky {
      border-radius: 3px;
      display: block;
      position: absolute;
      -webkit-appearance: none;
      padding: 4px;
    }
    .sheet-lucky:active, .sheet-lucky:checked:active {
      background-color: transparent;
    }
    .sheet-lucky:checked {
      border: none;
      color: red;
      background-color: transparent;
    }
    .sheet-lucky:checked::after {
      content: "X";
      font-size: 14px;
      position: absolute;
      top: 0px;
      left: 3px;
      color: red;
    }
    .sheet-coin-A {
      position: absolute;
      width: 10px;
      height: 10px;
    }
    .sheet-enc-level {
      position: absolute;
    }
    .sheet-stamina-dots {
      position: absolute;
      width: 22px;
      height: 330px;
      overflow: hidden;
      background-image: url("https://cdn.rawgit.com/FieryScubaDivingAccident/0cd0d9ef14fadf5e039c2fa0b814d8b6/raw/ae7f3fa0a8224823274cdcb1adfaa51610135976/eaba_stamina_vertical_light.svg");
      background-size: 22px 330px;
      background-repeat: no-repeat;
    }
    .sheet-repeatingarea-props {
      display: block;
      border-radius: 10px;
      margin: 8px;
      height: auto;
      position: relative;
      background-color: rgb(187, 187, 187);
    }
    .sheet-fillbox-input {
      position: absolute;
      font-family: arial;
      border: none;
      margin: 0px;
      padding: 0px;
      font-size: 12px;
      border-radius: 8px;
    }
    .sheet-notes-hidden {
      height: 24px;
    }
    input.sheet-notes-hider:checked ~ div.sheet-notes-hidden {
      display: none;
    }
    input.sheet-notes-hider {
      opacity: 0;
      width: 16px;
      height: 16px;
      position: relative;
      top: 5px;
      left: 26px;
      margin: -10px;
      cursor: pointer;
      z-index: 1;
    }
    input.sheet-notes-hider + span::before {
      margin-right: 4px;
      text-align: center;
      display: inline-block;
      vertical-align: middle;
      content: "▼";
      width: 14px;
      height: 14px;
      font-size: 16px;
      margin-left: 20px;
    }
    input.sheet-notes-hider:checked + span::before {
      content: "►";
    }
    .sheet-infobox-label {
      z-index: 0;
    }
    .sheet-infobox-hidden-info {
      display: none;
    }
    .sheet-infobox-label:hover + .sheet-infobox-hidden-info {
      display: block;
      position: relative;
      width: 120px;
      height: auto;
      z-index: 10;
      padding: 12px;
      font-family: arial;
      float: left;
      font-size: 12px;
      border-radius: 10px;
      box-shadow: rgba(1, 1, 1, 0.498039) 5px 5px 1px;
      background-color: rgb(255, 247, 214);
    }
    .sheet-infobox-head {
      font-weight: bold;
      font-size: 12px;
      line-height: 12px;
      padding-bottom: 4px;
    }
    .sheet-infobox-label:hover {
      color: rgb(32, 63, 109);
    }
    .sheet-infobox-label {
      font-family: arial;
      font-weight: bold;
      color: rgb(102, 123, 155);
    }
    .sheet-rollbox-selector {
      position: absolute;
      height: 14px;
      text-align: center;
      text-align-last: center;
      font-family: arial;
      font-size: 12px;
      border: none;
      -webkit-appearance: none;
      text-indent: 1px;
      font-weight: normal;
      padding: 0px !important;
      margin: 0px !important;
      line-height: 16px !important;
      background-color: transparent;
    }
    .sheet-page-headers {
      position: relative;
      height: 96px;
    }
    .sheet-eaba-logo {
      position: absolute;
      height: 88px;
      width: 176px;
      left: -1px;
      top: -4px;
    }
    .sheet-quick-dice-roller {
      position: absolute;
      width: 46px;
      height: 46px;
      left: 766px;
      top: 17px;
    }
    .sheet-big-dice-roller {
      position: absolute;
      width: 60px;
      height: 60px;
      left: 749px;
      top: 8px;
      opacity: 0;
      background: none;
    }
    .sheet-big-reveal {}
    .sheet-big-hide:checked + .sheet-big-reveal {
      display: block;
      position: relative;
      z-index: 10;
      padding: 12px;
      font-family: arial;
      float: left;
      font-size: 12px;
      border-radius: 10px;
      box-shadow: rgba(1, 1, 1, 0.498039) 5px 5px 1px;
      height: 120px;
      width: 200px;
      left: 590px;
      top: 75px;
      background-color: rgba(64, 64, 64, 0.901961);
    }
    .sheet-eaba-dmg-type-selector {
      z-index: 1;
      height: 22px;
      width: 22px;
    }
    .sheet-eaba-dmg-3waybox {
      z-index: 1;
      height: 22px;
      width: 22px;
    }
    .sheet-hits-area {
      position: absolute;
      height: 22px;
      overflow: hidden;
      left: 0px;
      top: 0px;
      width: 572px;
      background-image: url("https://cdn.rawgit.com/FieryScubaDivingAccident/b0117ce83ef09a54b1486e905166526b/raw/b7f899ec17c56114ad55a03a4ee3dd9e4c43ed19/hitboxes.svg");
      background-size: 572px 22px;
      background-repeat: no-repeat;
    }
    .sheet-eaba-dmg-hidden {}
    .sheet-quick-inventory-area {
      position: absolute;
      width: 762px;
      left: 36px;
      border-radius: 8px;
      border: none;
      resize: none;
      overflow-y: scroll;
      top: 20px;
      height: 108px;
    }
    .sheet-savings-area-stuff {
      left: 86px;
      top: 165px;
      width: 462px;
      background-image: url("https://cdn.rawgit.com/FieryScubaDivingAccident/400394da2ac572b84ddf6d782f9a76a7/raw/4af80237f86998aca7d37077e2c1bf255df78467/eaba_invested.svg");
    }
    .sheet-eaba-svngs-type-selector {
      height: 8px;
      width: 8px;
      z-index: 1;
    }
    .sheet-eaba-svngs-3waybox {
      height: 8px;
      width: 8px;
      z-index: 1;
    }
    ::-webkit-scrollbar {
      width: 12px;
      border-radius: 10px;
      background-color: white;
    }
    ::-webkit-scrollbar-track {
      box-shadow: rgb(0, 0, 0) 0px 0px 1px inset;
      border-radius: 10px;
    }
    ::-webkit-scrollbar-thumb {
      border-radius: 10px;
      box-shadow: rgb(0, 0, 0) 0px 0px 1px inset;
    }
    .sheet-universal-scale table, .sheet-universal-scale tr, .sheet-universal-scale td {
      font-family: arial;
      font-size: 10px;
      line-height: 12px;
      border-collapse: collapse;
      border: none;
      border-spacing: 0px;
      padding: 0px;
    }
    .sheet-universal-scale td {
      text-align: center;
      width: 40px;
    }
    .sheet-universal-scale tr:nth-child(2n+1) {
      background-color: rgb(255, 255, 255);
    }
    .sheet-eaba-universal-chart {
      position: absolute;
      width: 240px;
    }
    .sheet-universal-chart-div {
      position: absolute;
      width: 280px;
      overflow-y: scroll;
      height: 440px;
      top: 30px;
      left: 0px;
    }
    .sheet-npc-hit-locations {
      position: absolute;
      border-radius: 10px;
      width: 250px;
      height: 375px;
      top: 45px;
      left: 183px;
      background-image: url("https://i.imgur.com/FdWHlux.png");
      background-color: rgb(204, 204, 204);
      background-size: 250px 375px;
      background-repeat: no-repeat;
    }
    .sheet-npc-healthbar {
      left: 162px;
      top: 437px;
    }
    .sheet-stamina-container {
      position: absolute;
      width: 22px;
      height: 330px;
      left: 0px;
      top: 0px;
      background-image: url("https://i.imgur.com/O8kSf2z.png");
    }
    input.sheet-sta {
      position: absolute;
      top: 0px;
      left: 0px;
      height: 1px;
      width: 1px;
      opacity: 0;
    }
    input.sheet-sta[value="0"]:checked ~ div.sheet-stamina-dots {
      height: 330px;
    }
    input.sheet-sta[value="1"]:checked ~ div.sheet-stamina-dots {
      height: 22px;
    }
    input.sheet-sta[value="2"]:checked ~ div.sheet-stamina-dots {
      height: 44px;
    }
    input.sheet-sta[value="3"]:checked ~ div.sheet-stamina-dots {
      height: 66px;
    }
    input.sheet-sta[value="4"]:checked ~ div.sheet-stamina-dots {
      height: 88px;
    }
    input.sheet-sta[value="5"]:checked ~ div.sheet-stamina-dots {
      height: 110px;
    }
    input.sheet-sta[value="6"]:checked ~ div.sheet-stamina-dots {
      height: 132px;
    }
    input.sheet-sta[value="7"]:checked ~ div.sheet-stamina-dots {
      height: 154px;
    }
    input.sheet-sta[value="8"]:checked ~ div.sheet-stamina-dots {
      height: 176px;
    }
    input.sheet-sta[value="9"]:checked ~ div.sheet-stamina-dots {
      height: 198px;
    }
    input.sheet-sta[value="10"]:checked ~ div.sheet-stamina-dots {
      height: 220px;
    }
    input.sheet-sta[value="11"]:checked ~ div.sheet-stamina-dots {
      height: 242px;
    }
    input.sheet-sta[value="12"]:checked ~ div.sheet-stamina-dots {
      height: 264px;
    }
    input.sheet-sta[value="13"]:checked ~ div.sheet-stamina-dots {
      height: 286px;
    }
    input.sheet-sta[value="14"]:checked ~ div.sheet-stamina-dots {
      height: 308px;
    }
    input.sheet-sta[value="15"]:checked ~ div.sheet-stamina-dots {
      height: 330px;
    }

    input.sheet-sta[value="0"]:checked ~ div.sheet-hits-area {
      width: 572px;
    }
    input.sheet-sta[value="1"]:checked ~ div.sheet-hits-area {
      width: 22px;
    }
    input.sheet-sta[value="2"]:checked ~ div.sheet-hits-area {
      width: 44px;
    }
    input.sheet-sta[value="3"]:checked ~ div.sheet-hits-area {
      width: 66px;
    }
    input.sheet-sta[value="4"]:checked ~ div.sheet-hits-area {
      width: 88px;
    }
    input.sheet-sta[value="5"]:checked ~ div.sheet-hits-area {
      width: 110px;
    }
    input.sheet-sta[value="6"]:checked ~ div.sheet-hits-area {
      width: 132px;
    }
    input.sheet-sta[value="7"]:checked ~ div.sheet-hits-area {
      width: 154px;
    }
    input.sheet-sta[value="8"]:checked ~ div.sheet-hits-area {
      width: 176px;
    }
    input.sheet-sta[value="9"]:checked ~ div.sheet-hits-area {
      width: 198px;
    }
    input.sheet-sta[value="10"]:checked ~ div.sheet-hits-area {
      width: 220px;
    }
    input.sheet-sta[value="11"]:checked ~ div.sheet-hits-area {
      width: 242px;
    }
    input.sheet-sta[value="12"]:checked ~ div.sheet-hits-area {
      width: 264px;
    }
    input.sheet-sta[value="13"]:checked ~ div.sheet-hits-area {
      width: 286px;
    }
    input.sheet-sta[value="14"]:checked ~ div.sheet-hits-area {
      width: 308px;
    }
    input.sheet-sta[value="15"]:checked ~ div.sheet-hits-area {
      width: 330px;
    }
    input.sheet-sta[value="16"]:checked ~ div.sheet-hits-area {
      width: 352px;
    }
    input.sheet-sta[value="17"]:checked ~ div.sheet-hits-area {
      width: 374px;
    }
    input.sheet-sta[value="18"]:checked ~ div.sheet-hits-area {
      width: 396px;
    }
    input.sheet-sta[value="19"]:checked ~ div.sheet-hits-area {
      width: 418px;
    }
    input.sheet-sta[value="20"]:checked ~ div.sheet-hits-area {
      width: 440px;
    }
    input.sheet-sta[value="21"]:checked ~ div.sheet-hits-area {
      width: 462px;
    }
    input.sheet-sta[value="22"]:checked ~ div.sheet-hits-area {
      width: 484px;
    }
    input.sheet-sta[value="23"]:checked ~ div.sheet-hits-area {
      width: 506px;
    }
    input.sheet-sta[value="24"]:checked ~ div.sheet-hits-area {
      width: 528px;
    }
    input.sheet-sta[value="25"]:checked ~ div.sheet-hits-area {
      width: 550px;
    }
	 input.sheet-sta[value="26"]:checked ~ div.sheet-hits-area {
      width: 572px;
    }

    .sheet-hitwraps {
      position: absolute;
      left: 36px;
      top: 20px;
      width: 572px;
      height: 22px;
      background-image: url("https://i.imgur.com/O8kSf2z.png");
    }

input[type=number] {
    -moz-appearance:textfield;
	-webkit-box-shadow: none;
	-moz-box-shadow: none;
	box-shadow: none;
}

[disabled].sheet-rollbox-input{
	cursor:default;
	background-color:transparent;
	color:black;
	-webkit-box-shadow: none;
	-moz-box-shadow: none;
	box-shadow: none;
}

[disabled].sheet-attrbox-points-input {
	cursor:default;
	background-color:#fff;
	color:black;
	-webkit-box-shadow: none;
	-moz-box-shadow: none;
	box-shadow: none;
}

.charsheet {
	background:white;
	font-family:arial;
}

.repcontrol {
	height:30px;
}

.btn-danger{
    z-index:100;
}

/*Stamina Box Styles*/
.sheet-eaba-stamina-hidden{
  display: none !important;

}

input.sheet-eaba-stamina-type-selector {
  width: 22px;
  height: 22px;
  display: none;
  opacity: 0;
  z-index: 1;
  margin: 0;
  padding: 0;
  position: absolute;
}

.sheet-eaba-stamina-3waybox:checked + .sheet-eaba-stamina-3waybox, {
  display: inline-block;
  color:black;
}

/* Styling of the span common to all states */
span.sheet-eaba-stamina-type-selector {
  border: none;
  text-align: center;
  display: inline-block;
  background: transparent;
  width:22px;
  height: 22px;
  font-size: 18px;
  text-transform: uppercase;
  letter-spacing: 1px;
  font-family: serif;
  font-weight: 600;
  cursor: pointer;
}

/* Here you can style the span depending on what state is toggled */

input.sheet-eaba-stamina-type-selector[value="0"]:checked ~ span::before {
  content: " ";
}

input.sheet-eaba-stamina-type-selector[value="1"]:checked ~ span::before {
  content: url("https://imgur.com/7tPA2zw.png");
}

input.sheet-eaba-stamina-type-selector[value="2"]:checked ~ span::before {
  content: url("https://imgur.com/7tPA2zw.png");

}

input.sheet-eaba-stamina-type-selector[value="3"]:checked ~ span::before {
  content: url("https://i.imgur.com/O8kSf2z.png");

}

/* hit Styles*/
.sheet-eaba-dmg-hidden{
  display: none !important;
  font-size: 11px;
}

input.sheet-eaba-dmg-type-selector {
  width: 22px;
  height: 22px;
  display: none;
  opacity: 0;
  z-index: 1;
  margin: 0;
  padding: 0;
  position: absolute;
}

.sheet-eaba-dmg-3waybox:checked + .sheet-eaba-dmg-3waybox, {
  display: inline-block;
  color:black;
}

/* Styling of the span common to all states */
span.sheet-eaba-dmg-type-selector {
  border: none;
  text-align: center;
  display: inline-block;
  background: transparent;
  width: 22px;
  height: 22px;
  font-size: 11px;
  text-transform: uppercase;
  letter-spacing: 1px;
  font-family: serif;
  font-weight: 600;
  cursor: pointer;
}

/* Here you can style the span depending on what state is toggled */

input.sheet-eaba-dmg-type-selector[value="0"]:checked ~ span::before {
  content: " ";

}

input.sheet-eaba-dmg-type-selector[value="3"]:checked ~ span::before {
  content: url("https://i.imgur.com/O8kSf2z.png");

}

input.sheet-eaba-dmg-type-selector[value="1"]:checked ~ span::before {
  content: url("https://imgur.com/7tPA2zw.png");

}

input.sheet-eaba-dmg-type-selector[value="2"]:checked ~ span::before {
  content: url("https://imgur.com/YnaAqqb.png");

}

/* end stamina and hits */

/* hit Styles*/
.sheet-eaba-svngs-hidden{
  display: none !important;
  padding: 0px;
  margin: 0px;
}

input.sheet-eaba-svngs-type-selector {
  width: 22px;
  height: 22px;
  display: none;
  opacity: 0;
  z-index: 1;
  margin: 0;
  padding: 0;
  position: absolute;
}

.sheet-eaba-svngs-3waybox:checked + .sheet-eaba-svngs-3waybox, {
  display: inline-block;
  color:black;
}

/* Styling of the span common to all states */
span.sheet-eaba-svngs-type-selector {
  border: none;
  display: inline-block;
  background: transparent;
  width: 22px;
  height: 22px;
  cursor: pointer;
  padding: 0px;
  margin: 0px;
}

/* Here you can style the span depending on what state is toggled */

input.sheet-eaba-svngs-type-selector[value="0"]:checked ~ span::before {
  content: " ";
}

input.sheet-eaba-svngs-type-selector[value="3"]:checked ~ span::before {
  content: url("https://i.imgur.com/t7857yZ.png");

}

input.sheet-eaba-svngs-type-selector[value="2"]:checked ~ span::before {
  content: url("https://i.imgur.com/V7j3yHh.png");

}

input.sheet-eaba-svngs-type-selector[value="1"]:checked ~ span::before {
  content: url("https://i.imgur.com/0yxTAjH.png");

}


text:
import {CommonModule} from '@angular/common';
import {NgModule} from '@angular/core';
import {MatRippleModule} from '@angular/material/core';
import {MatButtonModule} from '@angular/material/button';
import {MatButtonToggleModule} from '@angular/material/button-toggle';
import {MatCheckboxModule} from '@angular/material/checkbox';
import {MatIconModule} from '@angular/material/icon';
import {MatInputModule} from '@angular/material/input';
import {MatPaginatorModule} from '@angular/material/paginator';
import {MatProgressSpinnerModule} from '@angular/material/progress-spinner';
import {MatSortModule} from '@angular/material/sort';
import {MatTableModule} from '@angular/material/table';
import {DragDropModule} from '@angular/cdk/drag-drop';
import {CdkTableModule} from '@angular/cdk/table';

import {TableFlexBasicExample} from './table-flex-basic/table-flex-basic-example';
import {TableBasicExample} from './table-basic/table-basic-example';
import {TableDynamicColumnsExample} from './table-dynamic-columns/table-dynamic-columns-example';
import {TableExpandableRowsExample} from './table-expandable-rows/table-expandable-rows-example';
import {TableFilteringExample} from './table-filtering/table-filtering-example';
import {TableFooterRowExample} from './table-footer-row/table-footer-row-example';
import {TableHttpExample} from './table-http/table-http-example';
import {TableMultipleHeaderFooterExample} from './table-multiple-header-footer/table-multiple-header-footer-example';
import {TableOverviewExample} from './table-overview/table-overview-example';
import {TablePaginationExample} from './table-pagination/table-pagination-example';
import {TableRowContextExample} from './table-row-context/table-row-context-example';
import {TableSelectionExample} from './table-selection/table-selection-example';
import {TableSortingExample} from './table-sorting/table-sorting-example';
import {TableStickyColumnsExample} from './table-sticky-columns/table-sticky-columns-example';
import {TableStickyComplexFlexExample} from './table-sticky-complex-flex/table-sticky-complex-flex-example';
import {TableStickyComplexExample} from './table-sticky-complex/table-sticky-complex-example';
import {TableStickyFooterExample} from './table-sticky-footer/table-sticky-footer-example';
import {TableStickyHeaderExample} from './table-sticky-header/table-sticky-header-example';
import {TableTextColumnAdvancedExample} from './table-text-column-advanced/table-text-column-advanced-example';
import {TableTextColumnExample} from './table-text-column/table-text-column-example';
import {TableWrappedExample, WrapperTable} from './table-wrapped/table-wrapped-example';
import {TableReorderableExample} from './table-reorderable/table-reorderable-example';
import {TableRecycleRowsExample} from './table-recycle-rows/table-recycle-rows-example';
import {TableHarnessExample} from './table-harness/table-harness-example';
import {TableWithRipplesExample} from './table-with-ripples/table-with-ripples-example';
import {TableColumnStylingExample} from './table-column-styling/table-column-styling-example';
import {TableRowBindingExample} from './table-row-binding/table-row-binding-example';
import {TableDynamicArrayDataExample} from './table-dynamic-array-data/table-dynamic-array-data-example';
import {TableDynamicObservableDataExample} from './table-dynamic-observable-data/table-dynamic-observable-data-example';
import {TableGeneratedColumnsExample} from './table-generated-columns/table-generated-columns-example';
import {TableFlexLargeRowExample} from './table-flex-large-row/table-flex-large-row-example';

export {
  TableBasicExample,
  TableColumnStylingExample,
  TableDynamicArrayDataExample,
  TableDynamicColumnsExample,
  TableDynamicObservableDataExample,
  TableExpandableRowsExample,
  TableFilteringExample,
  TableFlexBasicExample,
  TableFlexLargeRowExample,
  TableFooterRowExample,
  TableGeneratedColumnsExample,
  TableHarnessExample,
  TableHttpExample,
  TableMultipleHeaderFooterExample,
  TableOverviewExample,
  TablePaginationExample,
  TableRecycleRowsExample,
  TableReorderableExample,
  TableRowBindingExample,
  TableRowContextExample,
  TableSelectionExample,
  TableSortingExample,
  TableStickyColumnsExample,
  TableStickyComplexExample,
  TableStickyComplexFlexExample,
  TableStickyFooterExample,
  TableStickyHeaderExample,
  TableTextColumnAdvancedExample,
  TableTextColumnExample,
  TableWithRipplesExample,
  TableWrappedExample,
  WrapperTable,
};

const EXAMPLES = [
  TableBasicExample,
  TableColumnStylingExample,
  TableDynamicArrayDataExample,
  TableDynamicColumnsExample,
  TableDynamicObservableDataExample,
  TableExpandableRowsExample,
  TableFilteringExample,
  TableFlexBasicExample,
  TableFlexLargeRowExample,
  TableFooterRowExample,
  TableGeneratedColumnsExample,
  TableHarnessExample,
  TableHttpExample,
  TableMultipleHeaderFooterExample,
  TableOverviewExample,
  TablePaginationExample,
  TableRecycleRowsExample,
  TableReorderableExample,
  TableRowBindingExample,
  TableRowContextExample,
  TableSelectionExample,
  TableSortingExample,
  TableStickyColumnsExample,
  TableStickyComplexExample,
  TableStickyComplexFlexExample,
  TableStickyFooterExample,
  TableStickyHeaderExample,
  TableTextColumnAdvancedExample,
  TableTextColumnExample,
  TableWithRipplesExample,
  TableWrappedExample,
  WrapperTable,
];

@NgModule({
  imports: [
    CommonModule,
    MatButtonModule,
    MatButtonToggleModule,
    MatCheckboxModule,
    MatIconModule,
    MatInputModule,
    MatPaginatorModule,
    MatProgressSpinnerModule,
    MatRippleModule,
    MatSortModule,
    MatTableModule,
    CdkTableModule,
    DragDropModule,
  ],
  declarations: EXAMPLES,
  exports: EXAMPLES,
})
export class TableExamplesModule {}


text:
<graph id="Graph">
  <version>1.0</version>
  <node id="ProductSet-Reader">
    <operator>ProductSet-Reader</operator>
    <sources/>
    <parameters class="com.bc.ceres.binding.dom.XppDomElement">
      <fileList>${filelist}</fileList>
    </parameters>
  </node>
  <node id="BandMerge">
    <operator>BandMerge</operator>
    <sources>
      <sourceProduct.2 refid="ProductSet-Reader"/>
    </sources>
    <parameters class="com.bc.ceres.binding.dom.XppDomElement">
      <sourceBands/>
      <geographicError>1.0E-5</geographicError>
    </parameters>
  </node>
  <node id="BandMaths">
    <operator>BandMaths</operator>
    <sources>
      <sourceProduct refid="BandMerge"/>
    </sources>
    <parameters class="com.bc.ceres.binding.dom.XppDomElement">
      <targetBands>
        <targetBand>
          <name>mask</name>
          <type>Int8</type>
          <expression>(Gamma0_VV * Gamma0_VV_2) / (Gamma0_VV * Gamma0_VV_2)</expression>
          <description/>
          <unit/>
          <noDataValue>0.0</noDataValue>
        </targetBand>
      </targetBands>
      <variables/>
    </parameters>
  </node>
  <node id="Write">
    <operator>Write</operator>
    <sources>
      <sourceProduct refid="BandMaths"/>
    </sources>
    <parameters class="com.bc.ceres.binding.dom.XppDomElement">
      <file>${output}</file>
      <formatName>BEAM-DIMAP</formatName>
    </parameters>
  </node>
  <applicationData id="Presentation">
    <Description/>
    <node id="ProductSet-Reader">
      <displayPosition x="56.0" y="60.0"/>
    </node>
    <node id="BandMerge">
      <displayPosition x="208.0" y="101.0"/>
    </node>
    <node id="BandMaths">
      <displayPosition x="295.0" y="155.0"/>
    </node>
    <node id="Write">
      <displayPosition x="435.0" y="190.0"/>
    </node>
  </applicationData>
</graph>