text:
package fixtures.lro.implementation;

import retrofit2.Retrofit;
import com.google.common.reflect.TypeToken;
import com.microsoft.azure.CloudException;
import com.microsoft.rest.ServiceCallback;
import com.microsoft.rest.ServiceFuture;
import com.microsoft.rest.ServiceResponse;
import com.microsoft.rest.ServiceResponseWithHeaders;
import com.microsoft.rest.Validator;
import fixtures.lro.LROsCustomHeaderPost202Retry200Headers;
import fixtures.lro.LROsCustomHeaderPostAsyncRetrySucceededHeaders;
import fixtures.lro.LROsCustomHeaderPutAsyncRetrySucceededHeaders;
import java.io.IOException;
import okhttp3.ResponseBody;
import retrofit2.http.Body;
import retrofit2.http.Header;
import retrofit2.http.Headers;
import retrofit2.http.POST;
import retrofit2.http.PUT;
import retrofit2.Response;
import rx.functions.Func1;
import rx.Observable;

/**
 * An instance of this class provides access to all the operations defined
 * in LROsCustomHeaders.
 */
public class LROsCustomHeadersInner {
    /** The Retrofit service to perform REST calls. */
    private LROsCustomHeadersService service;
    /** The service client containing this operation class. */
    private AutoRestLongRunningOperationTestServiceImpl client;

    /**
     * Initializes an instance of LROsCustomHeadersInner.
     *
     * @param retrofit the Retrofit instance built from a Retrofit Builder.
     * @param client the instance of the service client containing this operation class.
     */
    public LROsCustomHeadersInner(Retrofit retrofit, AutoRestLongRunningOperationTestServiceImpl client) {
        this.service = retrofit.create(LROsCustomHeadersService.class);
        this.client = client;
    }

    /**
     * The interface defining all the services for LROsCustomHeaders to be
     * used by Retrofit to perform actually REST calls.
     */
    interface LROsCustomHeadersService {
        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders putAsyncRetrySucceeded" })
        @PUT("lro/customheader/putasync/retry/succeeded")
        Observable<Response<ResponseBody>> putAsyncRetrySucceeded(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders beginPutAsyncRetrySucceeded" })
        @PUT("lro/customheader/putasync/retry/succeeded")
        Observable<Response<ResponseBody>> beginPutAsyncRetrySucceeded(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders put201CreatingSucceeded200" })
        @PUT("lro/customheader/put/201/creating/succeeded/200")
        Observable<Response<ResponseBody>> put201CreatingSucceeded200(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders beginPut201CreatingSucceeded200" })
        @PUT("lro/customheader/put/201/creating/succeeded/200")
        Observable<Response<ResponseBody>> beginPut201CreatingSucceeded200(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders post202Retry200" })
        @POST("lro/customheader/post/202/retry/200")
        Observable<Response<ResponseBody>> post202Retry200(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders beginPost202Retry200" })
        @POST("lro/customheader/post/202/retry/200")
        Observable<Response<ResponseBody>> beginPost202Retry200(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders postAsyncRetrySucceeded" })
        @POST("lro/customheader/postasync/retry/succeeded")
        Observable<Response<ResponseBody>> postAsyncRetrySucceeded(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.lro.LROsCustomHeaders beginPostAsyncRetrySucceeded" })
        @POST("lro/customheader/postasync/retry/succeeded")
        Observable<Response<ResponseBody>> beginPostAsyncRetrySucceeded(@Body ProductInner product, @Header("accept-language") String acceptLanguage, @Header("User-Agent") String userAgent);

    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner putAsyncRetrySucceeded() {
        return putAsyncRetrySucceededWithServiceResponseAsync().toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> putAsyncRetrySucceededAsync(final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(putAsyncRetrySucceededWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ProductInner> putAsyncRetrySucceededAsync() {
        return putAsyncRetrySucceededWithServiceResponseAsync().map(new Func1<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>> putAsyncRetrySucceededWithServiceResponseAsync() {
        final ProductInner product = null;
        Observable<Response<ResponseBody>> observable = service.putAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPutOrPatchResultWithHeadersAsync(observable, new TypeToken<ProductInner>() { }.getType(), LROsCustomHeaderPutAsyncRetrySucceededHeaders.class);
    }
    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner putAsyncRetrySucceeded(ProductInner product) {
        return putAsyncRetrySucceededWithServiceResponseAsync(product).toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> putAsyncRetrySucceededAsync(ProductInner product, final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(putAsyncRetrySucceededWithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ProductInner> putAsyncRetrySucceededAsync(ProductInner product) {
        return putAsyncRetrySucceededWithServiceResponseAsync(product).map(new Func1<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>> putAsyncRetrySucceededWithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        Observable<Response<ResponseBody>> observable = service.putAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPutOrPatchResultWithHeadersAsync(observable, new TypeToken<ProductInner>() { }.getType(), LROsCustomHeaderPutAsyncRetrySucceededHeaders.class);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner beginPutAsyncRetrySucceeded() {
        return beginPutAsyncRetrySucceededWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> beginPutAsyncRetrySucceededAsync(final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(beginPutAsyncRetrySucceededWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ProductInner> beginPutAsyncRetrySucceededAsync() {
        return beginPutAsyncRetrySucceededWithServiceResponseAsync().map(new Func1<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>> beginPutAsyncRetrySucceededWithServiceResponseAsync() {
        final ProductInner product = null;
        return service.beginPutAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>>>() {
                @Override
                public Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders> clientResponse = beginPutAsyncRetrySucceededDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner beginPutAsyncRetrySucceeded(ProductInner product) {
        return beginPutAsyncRetrySucceededWithServiceResponseAsync(product).toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> beginPutAsyncRetrySucceededAsync(ProductInner product, final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(beginPutAsyncRetrySucceededWithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ProductInner> beginPutAsyncRetrySucceededAsync(ProductInner product) {
        return beginPutAsyncRetrySucceededWithServiceResponseAsync(product).map(new Func1<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 200 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>> beginPutAsyncRetrySucceededWithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        return service.beginPutAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>>>() {
                @Override
                public Observable<ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders> clientResponse = beginPutAsyncRetrySucceededDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponseWithHeaders<ProductInner, LROsCustomHeaderPutAsyncRetrySucceededHeaders> beginPutAsyncRetrySucceededDelegate(Response<ResponseBody> response) throws CloudException, IOException {
        return this.client.restClient().responseBuilderFactory().<ProductInner, CloudException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<ProductInner>() { }.getType())
                .registerError(CloudException.class)
                .buildWithHeaders(response, LROsCustomHeaderPutAsyncRetrySucceededHeaders.class);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner put201CreatingSucceeded200() {
        return put201CreatingSucceeded200WithServiceResponseAsync().toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> put201CreatingSucceeded200Async(final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromResponse(put201CreatingSucceeded200WithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ProductInner> put201CreatingSucceeded200Async() {
        return put201CreatingSucceeded200WithServiceResponseAsync().map(new Func1<ServiceResponse<ProductInner>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponse<ProductInner> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponse<ProductInner>> put201CreatingSucceeded200WithServiceResponseAsync() {
        final ProductInner product = null;
        Observable<Response<ResponseBody>> observable = service.put201CreatingSucceeded200(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPutOrPatchResultAsync(observable, new TypeToken<ProductInner>() { }.getType());
    }
    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner put201CreatingSucceeded200(ProductInner product) {
        return put201CreatingSucceeded200WithServiceResponseAsync(product).toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> put201CreatingSucceeded200Async(ProductInner product, final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromResponse(put201CreatingSucceeded200WithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ProductInner> put201CreatingSucceeded200Async(ProductInner product) {
        return put201CreatingSucceeded200WithServiceResponseAsync(product).map(new Func1<ServiceResponse<ProductInner>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponse<ProductInner> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponse<ProductInner>> put201CreatingSucceeded200WithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        Observable<Response<ResponseBody>> observable = service.put201CreatingSucceeded200(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPutOrPatchResultAsync(observable, new TypeToken<ProductInner>() { }.getType());
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner beginPut201CreatingSucceeded200() {
        return beginPut201CreatingSucceeded200WithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> beginPut201CreatingSucceeded200Async(final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromResponse(beginPut201CreatingSucceeded200WithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ProductInner> beginPut201CreatingSucceeded200Async() {
        return beginPut201CreatingSucceeded200WithServiceResponseAsync().map(new Func1<ServiceResponse<ProductInner>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponse<ProductInner> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ServiceResponse<ProductInner>> beginPut201CreatingSucceeded200WithServiceResponseAsync() {
        final ProductInner product = null;
        return service.beginPut201CreatingSucceeded200(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<ProductInner>>>() {
                @Override
                public Observable<ServiceResponse<ProductInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<ProductInner> clientResponse = beginPut201CreatingSucceeded200Delegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the ProductInner object if successful.
     */
    public ProductInner beginPut201CreatingSucceeded200(ProductInner product) {
        return beginPut201CreatingSucceeded200WithServiceResponseAsync(product).toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<ProductInner> beginPut201CreatingSucceeded200Async(ProductInner product, final ServiceCallback<ProductInner> serviceCallback) {
        return ServiceFuture.fromResponse(beginPut201CreatingSucceeded200WithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ProductInner> beginPut201CreatingSucceeded200Async(ProductInner product) {
        return beginPut201CreatingSucceeded200WithServiceResponseAsync(product).map(new Func1<ServiceResponse<ProductInner>, ProductInner>() {
            @Override
            public ProductInner call(ServiceResponse<ProductInner> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running put request, service returns a 201 to the initial request, with an entity that contains ProvisioningState='Creating'.  Polls return this value until the last poll returns a '200' with ProvisioningState='Succeeded'.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the ProductInner object
     */
    public Observable<ServiceResponse<ProductInner>> beginPut201CreatingSucceeded200WithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        return service.beginPut201CreatingSucceeded200(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<ProductInner>>>() {
                @Override
                public Observable<ServiceResponse<ProductInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<ProductInner> clientResponse = beginPut201CreatingSucceeded200Delegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<ProductInner> beginPut201CreatingSucceeded200Delegate(Response<ResponseBody> response) throws CloudException, IOException {
        return this.client.restClient().responseBuilderFactory().<ProductInner, CloudException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<ProductInner>() { }.getType())
                .register(201, new TypeToken<ProductInner>() { }.getType())
                .registerError(CloudException.class)
                .build(response);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void post202Retry200() {
        post202Retry200WithServiceResponseAsync().toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> post202Retry200Async(final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(post202Retry200WithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<Void> post202Retry200Async() {
        return post202Retry200WithServiceResponseAsync().map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>> post202Retry200WithServiceResponseAsync() {
        final ProductInner product = null;
        Observable<Response<ResponseBody>> observable = service.post202Retry200(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPostOrDeleteResultWithHeadersAsync(observable, new TypeToken<Void>() { }.getType(), LROsCustomHeaderPost202Retry200Headers.class);
    }
    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void post202Retry200(ProductInner product) {
        post202Retry200WithServiceResponseAsync(product).toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> post202Retry200Async(ProductInner product, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(post202Retry200WithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<Void> post202Retry200Async(ProductInner product) {
        return post202Retry200WithServiceResponseAsync(product).map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>> post202Retry200WithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        Observable<Response<ResponseBody>> observable = service.post202Retry200(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPostOrDeleteResultWithHeadersAsync(observable, new TypeToken<Void>() { }.getType(), LROsCustomHeaderPost202Retry200Headers.class);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void beginPost202Retry200() {
        beginPost202Retry200WithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> beginPost202Retry200Async(final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(beginPost202Retry200WithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<Void> beginPost202Retry200Async() {
        return beginPost202Retry200WithServiceResponseAsync().map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>> beginPost202Retry200WithServiceResponseAsync() {
        final ProductInner product = null;
        return service.beginPost202Retry200(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>>>() {
                @Override
                public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers> clientResponse = beginPost202Retry200Delegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void beginPost202Retry200(ProductInner product) {
        beginPost202Retry200WithServiceResponseAsync(product).toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> beginPost202Retry200Async(ProductInner product, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(beginPost202Retry200WithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<Void> beginPost202Retry200Async(ProductInner product) {
        return beginPost202Retry200WithServiceResponseAsync(product).map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with 'Location' and 'Retry-After' headers, Polls return a 200 with a response body after success.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>> beginPost202Retry200WithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        return service.beginPost202Retry200(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>>>() {
                @Override
                public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers> clientResponse = beginPost202Retry200Delegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponseWithHeaders<Void, LROsCustomHeaderPost202Retry200Headers> beginPost202Retry200Delegate(Response<ResponseBody> response) throws CloudException, IOException {
        return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
                .register(202, new TypeToken<Void>() { }.getType())
                .registerError(CloudException.class)
                .buildWithHeaders(response, LROsCustomHeaderPost202Retry200Headers.class);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void postAsyncRetrySucceeded() {
        postAsyncRetrySucceededWithServiceResponseAsync().toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> postAsyncRetrySucceededAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(postAsyncRetrySucceededWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<Void> postAsyncRetrySucceededAsync() {
        return postAsyncRetrySucceededWithServiceResponseAsync().map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>> postAsyncRetrySucceededWithServiceResponseAsync() {
        final ProductInner product = null;
        Observable<Response<ResponseBody>> observable = service.postAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPostOrDeleteResultWithHeadersAsync(observable, new TypeToken<Void>() { }.getType(), LROsCustomHeaderPostAsyncRetrySucceededHeaders.class);
    }
    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void postAsyncRetrySucceeded(ProductInner product) {
        postAsyncRetrySucceededWithServiceResponseAsync(product).toBlocking().last().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> postAsyncRetrySucceededAsync(ProductInner product, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(postAsyncRetrySucceededWithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<Void> postAsyncRetrySucceededAsync(ProductInner product) {
        return postAsyncRetrySucceededWithServiceResponseAsync(product).map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>> postAsyncRetrySucceededWithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        Observable<Response<ResponseBody>> observable = service.postAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent());
        return client.getAzureClient().getPostOrDeleteResultWithHeadersAsync(observable, new TypeToken<Void>() { }.getType(), LROsCustomHeaderPostAsyncRetrySucceededHeaders.class);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void beginPostAsyncRetrySucceeded() {
        beginPostAsyncRetrySucceededWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> beginPostAsyncRetrySucceededAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(beginPostAsyncRetrySucceededWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<Void> beginPostAsyncRetrySucceededAsync() {
        return beginPostAsyncRetrySucceededWithServiceResponseAsync().map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>> beginPostAsyncRetrySucceededWithServiceResponseAsync() {
        final ProductInner product = null;
        return service.beginPostAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>>>() {
                @Override
                public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders> clientResponse = beginPostAsyncRetrySucceededDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws CloudException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void beginPostAsyncRetrySucceeded(ProductInner product) {
        beginPostAsyncRetrySucceededWithServiceResponseAsync(product).toBlocking().single().body();
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> beginPostAsyncRetrySucceededAsync(ProductInner product, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromHeaderResponse(beginPostAsyncRetrySucceededWithServiceResponseAsync(product), serviceCallback);
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<Void> beginPostAsyncRetrySucceededAsync(ProductInner product) {
        return beginPostAsyncRetrySucceededWithServiceResponseAsync(product).map(new Func1<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>, Void>() {
            @Override
            public Void call(ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders> response) {
                return response.body();
            }
        });
    }

    /**
     * x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required message header for all requests. Long running post request, service returns a 202 to the initial request, with an entity that contains ProvisioningState='Creating'. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status.
     *
     * @param product Product to put
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponseWithHeaders} object if successful.
     */
    public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>> beginPostAsyncRetrySucceededWithServiceResponseAsync(ProductInner product) {
        Validator.validate(product);
        return service.beginPostAsyncRetrySucceeded(product, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>>>() {
                @Override
                public Observable<ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders> clientResponse = beginPostAsyncRetrySucceededDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponseWithHeaders<Void, LROsCustomHeaderPostAsyncRetrySucceededHeaders> beginPostAsyncRetrySucceededDelegate(Response<ResponseBody> response) throws CloudException, IOException {
        return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
                .register(202, new TypeToken<Void>() { }.getType())
                .registerError(CloudException.class)
                .buildWithHeaders(response, LROsCustomHeaderPostAsyncRetrySucceededHeaders.class);
    }

}

redpajama_set_name: RedPajamaGithub


text:
Inside Biden's Oval Office: Cesar Chavez, presidential portraits
Carter Page sues over Russia investigation surveillance
Carter Web page alleges the FBI and DOJ made a collection of omissions and errors in functions they submitted to snoop on him on suspicion he was a Russia agent.
WASHINGTON — Editor's observe: The associated video above was revealed in February 2018.
A former Trump marketing campaign affiliate who was the goal of a secret surveillance warrant in the course of the FBI's Russia investigation says in a federal lawsuit that he was the sufferer of "illegal spying."
The swimsuit from Carter Web page alleges a collection of omissions and errors made by FBI and Justice Division officers in functions they submitted in 2016 and 2017 to the Overseas Intelligence Surveillance Court docket to snoop on Web page on suspicion that he was an agent of Russia.
"Since not a single indisputable fact ever established complicity with Russia involving Dr. Web page, there by no means was possible trigger to hunt or get hold of the FISA Warrants concentrating on him on this foundation," the lawsuit says, utilizing the acronym for the Overseas Intelligence Surveillance Act.
Web page has obtained dying and kidnapping threats and has suffered financial losses and "irreparable injury to his status," in response to the lawsuit, which was filed Friday in federal courtroom in Washington.
The lawsuit to some extent echoes the conclusions of a Justice Division inspector common report that discovered vital issues with the 4 functions. Former FBI and Justice Division leaders who have been concerned in signing off on the surveillance have since testified they would not have achieved so had they identified of the extent of the problems, and the FBI has initiated greater than 40 corrective steps geared toward enhancing the accuracy and thoroughness of functions.
RELATED: Ex-FBI lawyer to plead responsible in Durham have a look at Russia probe
RELATED: FBI: Overview of surveillance functions discovered minor errors
Within the criticism, Web page accuses the FBI of relying excessively for data on Christopher Steele, a former British spy whose analysis in the course of the 2016 marketing campaign into Donald Trump's ties to Russia was funded by Democrats. It says the FBI failed to inform the surveillance courtroom that Steele's main supply had contradicted data that Steele had attributed to him, or that Web page had denied to an informant for the FBI having "any involvement with Russia on behalf of the Trump marketing campaign."
The criticism additionally accuses the FBI of getting misled the surveillance courtroom about his relationship with the CIA, for whom Web page had been an operational contact between 2008 and 2013. A former FBI lawyer, Kevin Clinesmith, pleaded responsible in August to altering an e-mail to say that Web page had not been a supply for the CIA.
The swimsuit names as defendants the FBI and the Justice Division, in addition to former FBI Director James Comey, former FBI Deputy Director Andrew McCabe and extra officers who have been concerned within the Russia investigation.
Regardless of the issues with the warrant functions, the scrutiny of Web page, who was by no means charged with any wrongdoing, accounted for under a slim portion of the general investigation into ties between the Trump marketing campaign and Russia.
The identical inspector common report that detailed issues within the functions additionally concluded that the FBI had a professional foundation for opening the Russia investigation, and didn't discover proof that any of its actions have been influenced by political bias.
Cindy has great experience in creating and editing articles on different topics. She loves to read novels and write about the latest topics. She's also good at writing for our website. You can shoot mail @ cindy@rexweyler.com to discuss anything current topic.
Vanderbilt kicker Fuller becomes first woman to play in Power 5
Real Christmas trees bright spot many turning to amid pandemic

redpajama_set_name: RedPajamaCommonCrawl


text:
"Elegant house overlooking the village green with an open fire and a spacious kitchen" - VisitEngland Assessor
West Burton, North Yorkshire
Assessed by
An elegant and distinctive house overlooking the large village green in West Burton that sleeps eight people, plus one well behaved dog, very comfortably. There are two large lounges, one with an open fire, a spacious kitchen, private garden to the rear and four bedrooms, one en suite, and a house bathroom. West Burton has a village shop, a butcher, pub, The Cat Pottery and the pretty Cauldron Falls. Many walks start from here for you to enjoy.
Awards, accolades & Welcome Schemes
4 Star Self-Catering
Awards and ratings may only apply to specific accommodation units at this location.
West Burton, North yorkshire, DL8 3HS
Craggley Cottage
Leyburn , North Yorkshire
Flag Cottage
West Burton , North Yorkshire
Beck Side
Bridge View
Aysgarth Lodges
Aysgarth , North Yorkshire
The Wensleydale Heifer
AA Rosette Award
Dining on super-fresh fish and seafood isn't the first thing that comes to mind when you're in the heart of the beautiful Yorkshire Dales National Park, but this chic 17th-century inn with boutique rooms draws foodies from far and wide for its...
Built in 1631, this white-painted coaching inn is right in the heart of the Yorkshire Dales National Park. For a morning coffee, head for the Whisky Lounge, where you can indeed also enjoy a malt whisky, or a pint of Heifer Gold or Black Sheep real...
A visitor centre usefully stocked with maps, guides, walks and local information. Interactive displays explain the history and natural history of the area. Plan the day ahead with a light lunch in the coffee shop. Various guided walks begin here...
Explore the maze of rooms and passageways at this impressive castle, once the boyhood home of the ill-fated Richard III. Oak viewing gallery of the magnificent views of the 12th-century keep and exhibition.
West of Reeth you'll find this 200-acre organic working farm where you can interact with the livestock, discover nature trails and watch the sheep-shearing demonstrations and other events. April and May are the best months to see lambs. With tray...
FROM NIGHTLY
Title Mr Mrs Miss Ms Dr (male) Dr (female) Prof (male) Prof (female) Other
Remove Guest


text:
The Song Remains the Same for Zepp; Dylan Donnelly Doubles Down; Second Best is Plenty Good Three Different Times for Stephen Thompson (Weekend Recap February 21-23)
Posted on February 24, 2020 by ericwing
For what was sort of a quiet, "in-between" weekend on the racing calendar, things sure were busy around here. We had 24 featured events on Friday. Saturday and Sunday. In the process, next weekend's $100,000 Guaranteed Flo-Cal Faceoff transformed into the $106,000 Flo-Cal Faceoff as we blew past the guarantee. That purse will continue to grow, of course, as we conduct our final qualifiers this week. We also offered several All Optional Live tourneys on Saturday and Sunday. As usual, however, Friday belonged to Pick & Prays.
The Oscar for Best Handicapper on Friday went to Dylan Donnelly. He had the day's highest priced winner in Encountress ($46.00, $16.00 in the 3rd at Santa Anita) among his five winners and two runners up from just 10 plays to take the top prize of $4,987 in Friday's $7,500 Guaranteed Pick & Pray, which finished up with a final purse of $9,975.
Happily for Donnelly, he played those same picks in Friday's $75 NHC qualifier at HorsePlayers.
Also getting an early NHC seat here was Mike Ferrozzo (5 wins, 1 place). Both Donnelly and Ferrozzo had Encountress. In fact, the top 37 finishers (and 63 entrants overall) out of the field of 386 had the 22-1 shot.
The Oscar for Best Supporting Handicapper on Friday went to Stephen Thompson.
The Lebanon, Penn., funeral home director received this prestigious distinction not just for earning a pair of contest seats in Friday qualifiers…but by doing so via second-place finishes in both events. In our Flo-Cal Faceoff qualifier, Thompson finished ahead of all but Joe Johnson. The third- and fourth-place finishers—Lawrence Kahlden and Steven Meier—also picked of $1,500 entries to next Saturday and Sunday's Faceoff.
Thompson's score, built on 3 wins and a place, improved a bit in Friday's Horse Player World Series qualifier.
Here he finished second to Josh Thorpe who had five firsts and two seconds. Thorpe and Thompson will both be headed to Vegas on the last weekend in March for the "March Major" at The Orleans.
Only two players had Santa Anita longshot Encountress in Friday's Breeders' Cup Betting Challenge Low Ratio qualifier.
One was Joseph "38th" Parella, who had three wins and one place overall to pick up the coveted $10,000 entry. The other was runner up Frank Story who received a $5,000 partial BCBC entry.
On Saturday, with All Optional Live tourneys kicking in, Friday's "double bridesmaid" Stephen Thompson was back where he apparently liked to be…in second place!
Not that Thompson's complaining! The affable on-air personality Tom Cassidy punched his ticket to the next NHC thanks to 6 wins (including three at odds of 29-1, 14-1 and 14-1 again)…and so did Thompson for yet another extremely productive runner-up effort. Here, Thompson recorded 4 wins—three of which reported home at 13-1, 29-1 and 14-1.
That NHC qualifier was a traditional 12-race Pick & Pray. The day's (and weekend's) richest tourney was Saturday's All Optional Live $15,000 Guaranteed cash tourney. Stephen Thompson was way out of character in this one.
He won! Thompson showed versatility across formats by recording one additional winner (5) in two fewer races/plays (10). It added up to a payday of $9,088 in a game that ended up with a pot of $18,177. It also brought Thompson's cash winnings for the month of February up to $19,856 since he also won our $23,930 cash tourney on February 1.
There were 12 weekend winners (four each day) of $1,500 Flo-Cal Faceoff entries.
Saturday's quartet was Jeff Bussan, Marc Racenstein, Daven Turner and Mark Wilgard. They will all be tackling the full cards at Gulfstream and Santa Anita next Saturday and Sunday in hopes of taking home a piece of a purse that will be at least $106,000 (including Day Money prizes each day).
Tom Timlick didn't bother with place collections.
But his three winners certainly made up for that, coming home at odds of 13-1, 14-1 and 36-1. That got him first place by a comfy margin of $53.00 in Saturday's Horse Player World Series Full Package qualifier. Well back in second—but also garnering an entry/hotel/travel package to the HPWS—was The People's CFO, Joe "JK" Koury.
The Gotham Challenge is coming up at Aqueduct on March 9.
James Michael will be there after recording a $29.00 victory in Saturday's Big A qualifier. So will the silver and bronze medalists, Leonard "Hubble" Telesca and Togo "Cup" Travailia.
Chris Cupples had 4 winners and hit 3 of his final 5 plays to check in first in All Optional Live Keeneland Grade One Gamble qualifier.
Cupples will advance to Keeneland on April 19 with a $3,500 "Gamble" entry plus $500 for travel to Big Blue Nation.
Cupples was less fortunate in Saturday's live-format, 12-race Breeders' Cup Betting Challenge qualifier.
Cupples was leading going into the last race, but got passed late by Joe "Cosmo" Kramer when 14-1 Almashriq won the 12th at Gulfstream. You can't accuse Kramer of stabbing at a last-race longshot, though, as Almashriq was apparently part of Kramer's plan all along.
We saw a few players good naturedly sporting yellow and black "Fourgate" t-shirts at the recent NHC. Perhaps we'll see the same at this year's BCBC. (And for those of you wondering…yes…there was no 4 horse in the one race that Kramer went with a 3.)
Despite the fact that she only occasionally selects the number 4 horse, no one has been hotter of late than Alexa Zepp. She won multiple tourneys here at HorseTourneys over NHC weekend, she added a BCBC seat the following weekend and Zepp rambled on with another celebration day this past Sunday.
Here, it was a $50.90 triumph—good for a $3,500 package to the TSG Ultimate Betting Challenge on March 7. Zepp really gave no quarter to her foes in this one, posting the day's high featured-tourney score—a 10-play tour de force that included both a 68-1 winner and a 40-1 winner.
Robert M. Moore almost scored as high as Zepp.
His tally of $136.40 led a parade of four winners that included David Joy, Adam Lewis and Joe Koury in Sunday's Horse Player World Series qualifier. For Koury, it was his second HPWS win in as many days.
We offered a Low Ratio Flo-Cal Faceoff qualifier on Sunday and as with the "regular ratio" qualifiers on Friday and Saturday, the competition yielded four winners.
Sam DeCicco (1st), Bruce Pratt (3rd) and Grier Bibby (4th) all had The Last Ruler (40-1 in the 6th at Santa Anita) as their chief scoring contributor. Mack McClyment missed that one but hit several other very nice priced winners to take second and get a $1,500 Faceoff entry of his own,.
In All Optional Live qualifiers, a common strategy seems to be to save plays for the end so you can see what type of score you need to prosper. Allan Sadler didn't bother with any of that on Sunday.
Sadler played 6 of the first 9 contest races (out of a total of 25) and caught a 68-1 winner and a 5-1 winner in that stretch to build a lead that couldn't be overcome in Sunday's regular $10,000 Guaranteed cash tourney. Sadler ended the game with $103.40 and a check for $6,601…in a game that ultimately had a purse of $14,668.
Compared to Sadler, Michael Somich took an opposite approach to success.
Somich whiffed on his first eight picks, but he connected on 40-1 (The Last Ruler) and 3-1 winners with his last two, and that got him up to win our 17-person qualifier to The BIG One. Somich receives an all-inclusive package to the Sept. 19-20 tournament that will have a field of no more than 57 (53 qualifiers plus up to four buy-in entries).
G.T. Nixon had basically the same day as Somich.
He went zero-for-eight, then hit 40-1 and 3-1 shots to enter the winner's circle of our Monmouth Pick Your Prize qualifer, Runner up and fellow $2,500 package winner Peter Osella had five firsts and one second…and like Nixon, he had Proud Pedro (3-1) in the final race to secure his path to the Jersey Shore.
Jared Hagaman wasted no time imposing his will on Sunday's Keeneland Grade One Gamble Low Ratio qualifier.
He had Ballie's Dream in the very first contest race, the 5th at Gulfstream. That winner returned $33.80 and $10.60. Hagaman added two more winners and three places from there to nail down the $4,000 Keeneland package.
Craig "There's no place like" Hom has been specializing in big-ticket scores of late. The highly-skilled player cashed for $11,597 in a $25,771 game on February 15. Eight days later, Hom struck again.
Hom recorded three wins and four places in our $10,000 Guaranteed Big Bucks tourney to add another $7,124 to his coffers. Gary Blair was the only other competitor to show a flat-bet profit—and was rewarded with a 2nd-place prize of $2,035 for his troubles.
Elizabeth Canning had three winners in our $1,000 Guaranteed Exacta tourney…but one of them did almost all of the heavy lifting for her.
She hit the 1st at Santa Anita (the race won by 68-1 Princess Mo) to the tune of $215.60 for a buck, and that left the others in permanent chase mode. Canning won $765.
As fate would have it, that Princess Mo race also happened to be the first race in Sunday's $8 Pick 6 Jackpot tourney.
None of the tourney's 103 entrants had Princess Mo—which automatically triggered a Jackpot of $5,665 for next Sunday. "The Commissioner" Tim Smith did the best job of everyone "post-Princess Mo".
Maybe Ken Seeman and Kevin Engelhard should have played in the $8 Pick 6 Jackpot game.
Instead, they'll just have to settle for NHC seats. They both had Princess Mo en route to comparable 3-win, 2-place days in Sunday's "regular qualifier at HorsePlayers.
Add Thomas Murphy's name to the list of those who were on the right side of the Princess Mo photo.
The 68-1 shot helped Murphy dropkick his foes and win by $33.80 in Sunday's Breeders' Cup Betting Challenge Pick & Pray at HorsePlayers.
Before we go, we want to remind you about our new "Points Based" tourneys. We've been offering "free samples" of these lately to get people used to the 100-50-30 scoring method for firsts, seconds and thirds. Bonus points are also awarded to win and place horses based on their parimutuel payouts.
Steven Orden seems to already have a hang for these games.
And perhaps he, too, should consider signing up for this week's $8 Pick 6 Jackpot tourney. We know he has the funds in his account to cover it!
Have a great week. Hope to "see" many of you at the Flo-Cal.
1 thought on "The Song Remains the Same for Zepp; Dylan Donnelly Doubles Down; Second Best is Plenty Good Three Different Times for Stephen Thompson (Weekend Recap February 21-23)"
Mike Barone on February 24, 2020 at 6:28 pm said:
I won 2 of your points based tests today at Parx and Friday at Gulfstream and just missed at S. Anita on Saturday with a 2nd place finish…..thx for running those mike barone


text:
Q: How to select a particular word between non-alphabet characters? I have below values in a column.
TOM-TOM
TOMMY
TOM 12
123_TOM
SITTOM
TOM TIM
TOM,TIN
TOP TOM TON
TOMA
ATOM

How to select only these rows:
TOM-TOM
TOM 12
123_TOM
TOM TIM
TOM,TIN
TOP TOM TON

but not the below rows
SITTOM
TOMMY
TOMA
ATOM

If one character before or after TOM is a non-alphabet, those rows should be shown.

A: You can achieve this with a straightforward query using REGEXP_LIKE:
select t.col
from table t
where regexp_like(t.col, '(^|[^a-zA-Z])TOM([^a-zA-Z]|$)')

Here's a breakdown of a regular expression used:

*

*^|[^a-zA-Z] - start of a line or non-alphabetic character;

*TOM - TOM;

*([^a-zA-Z]|$) - end of a line or non-alphabetic character.

If you want to take non-english letters into account, you can use :alpha: instead of a-zA-Z:
select t.col
from t
where regexp_like(t.col, '(^|[^[:alpha:]])TOM([^[:alpha:]]|$)')

Try this on SQLFiddle: http://sqlfiddle.com/#!4/439b6/1

redpajama_set_name: RedPajamaStackExchange


text:
Bloody disco fight in SanRem: Police officer dies
Paul Lauro 12/08/2022
CEBU CITY, Philippines – A bloody altercation among neighbors in a residential area in San Remigio town, northern Cebu has claimed a life. Police from San Remigio confirmed on Thursday, December 8 that one of their…
PDEA district chief, 2 other agents nabbed; P9.1M worth of shabu seized in Taguig drug sting
Daphne Galvez 12/07/2022
MANILA, Philippines — A district office chief of the Philippine Drug Enforcement Agency (PDEA) and two other agents have been arrested in a buy-bust operation in Taguig City. In a police report on Wednesday, the National…
Pharmacy in Liloan loses P115,000 cash to thieves
CEBU CITY, Philippines – Still unidentified thieves broke into a pharmacy in Liloan town, northern Cebu, and took off with at least P115,000 worth of cash last Wednesday, Nov. 30. Police in Liloan, northern Cebu confirmed that…
Security guard killed in San Fernando
CEBU CITY, Philippines – Police in San Fernando town, southern Cebu are now looking into the killing of a security guard there last Wednesday evening, November 30, 2022. Police confirmed receiving a shooting alarm around 8 p.m.…
Man shot dead after argument with common-law wife
Pegeen Maisie Sararana 11/28/2022
CEBU CITY, Philippines — A heated argument between live-in-partners resulted to the death of a 41-year-old man in Sitio Balhaan, Barangay Madridejos in Alegria, Cebu, past 5 p.m. on Sunday, November 27, 2022. Police Lieutenant Alexius Tangub,…
Backhoe operator finds dead man, with face covered with bruises, in vacant lot in SRP
Morexette Marie Erram, Paul Lauro 11/17/2022
CEBU CITY, Philippines — A dead man, whose face was covered with bruises, was found in a vacant lot in the South Road Properties (SRP) in Cebu City on Thursday morning, Nov. 17. Police Major Jonathan Taneo,…
Thieves carted away valuables worth P800,000 from jewelry store in Lapu-Lapu
Morexette Marie B. Erram 11/16/2022
CEBU CITY, Philippines – Police in Lapu-Lapu City confirmed that thieves struck a jewelry store located inside a mall there, and took away valuables amounting to more than P800,000. Police Major Karen Bancoleta, chief of Lapu-Lapu City…
Police officer found dead in police camp barracks in Sibonga
CEBU CITY, Philippines – Investigations are now ongoing to shed light on the death of a police officer in Sibonga town, southern Cebu. Police in Sibonga confirmed that a policeman was found dead inside his barracks in…
Mother and son arrested for allegedly stealing P3M cash from elderly in Toledo
CEBU CITY, Philippines – Police in Toledo City arrested a mother and her son for allegedly stealing P3 million worth of cash from the house of a 73-year-old man there. Toledo City Police Station, in a press…
Lolo in Moalboal, Cebu found lying with stab wounds
CEBU CITY, Philippines – A 74-year-old man was rushed to a hospital in Moalboal town, southwestern Cebu after he was seen lying on the ground with multiple stab wounds on Wednesday morning, September 14. Police in Moalboal…
11 basketball players nabbed for illegal gambling in Balamban
CEBU CITY, Philippines — Basketball players in a village in Balamban, western Cebu were startled when police paid them a surprise visit. Police in Balamban confirmed apprehending 11 individuals playing basketball and at the same time, engaging…
In Dalaguete, bloody fight between pa, son over passenger
CEBU CITY, Philippines – A father and his son from Dalaguete town in southern Cebu got into a bloody fight over a passenger last Tuesday, July 12, 2022, the police confirmed. The incident happened in Sitio Guiwanon,…


text:
Q: Python: get an .exe file, and setting its icon I'm looking for a function that gets an .exe file's path, gets his icon, changes it, and setting his icon to the new icon.
It will be something like this:
def set_icon(exe_path):
    ico = get(exe_path)
    ico = change(ico)
    set(exe_path, ico)

I realy don't know how to do the get and set functions.
Can you help me please?


After sharing his debut EP in June of last year, London-based indie pop artist Alessandro Ciminata shared a few weeks ago his new track "Last Call" that was presented by our collaborator Deer Du Bois on his last playlist. He now, has decided to premiere the video for it, here on Highclouds.
Co-produced by Richard Frenneaux, who is behind the works of Laura Welsh, "Last Call" has captivating sounds, catchy choruses and impressively intimate lyrics. Embracing electronic vibes in this new twist for his career, he delivers a perfect love song, just after Valentine's Day. His own personal style floats in a place between Alex Vargas and Jack Garratt. The video showcases a vintage turn, showing his personal love for old glamorous romance.
You can follow Alessandro Ciminata over Facebook, Twitter, Instagram and Soundcloud. You can also listen to the audio of "Last Call" below.


text:
Q: UWP App working on desktop, but crash on windows phone Consider the following code which draws a line on the UWP MapControl:
if (mPoints.Count >= 2)
{
  var shape = new MapPolyline
  {
     StrokeThickness = 3,
     StrokeColor = Colors.Green,
     StrokeDashed = true,
     ZIndex = 1,
     Path = new Geopath(mPoints.Take(2))
  };
  mapControl.MapElements.Add(shape);

It works on windows 10 desktop, but crashes on mPoints.Take(2) (mPoints has 2 elements) on Windows Phone
Changing it to the following fixes the problem:
List<BasicGeoposition> l = new List<BasicGeoposition>() { mPoints[0], mPoints[1] };

                    var shape = new MapPolyline
                    {
                        StrokeThickness = 3,
                        StrokeColor = Colors.Green,
                        StrokeDashed = true,
                        ZIndex = 1,
                        Path = new Geopath(l)
                    };
                    mapControl.MapElements.Add(shape);

But I'd really like to know why the Linq version is not working on windows phone? Is this a bug in the uwp platform, am I using Take wrong or is this not implemented yet?
BTW, it was tested on a Lumia 930 and a Lumia 650, it crashed on both