text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a template.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// C:\Proyectos\azure-mobile-services\sdk\Managed\src\Microsoft.WindowsAzure.MobileServices\Resources.tt
// C:\Proyectos\azure-mobile-services\sdk\Managed\src\Microsoft.WindowsAzure.MobileServices
// 51
//------------------------------------------------------------------------------

namespace Microsoft.WindowsAzure.MobileServices
{
    using System;
    using System.Reflection;
    using System.Resources;
    using System.Collections.Generic;

    /// <summary>
    ///  Resource manager for Resources
    /// </summary>
    public static class Resources    {
                /// <summary>
        ///  Localized value for IApplicationStorage_NullOrWhitespaceSettingName.
        ///  Default value: 'An application setting name must be provided. Null, empty or whitespace only names are not allowed.'
        /// </summary>
        public static string IApplicationStorage_NullOrWhitespaceSettingName { get { return @"An application setting name must be provided. Null, empty or whitespace only names are not allowed."; } }
        /// <summary>
        ///  Localized value for IAuthenticationBroker_AuthenticationCanceled.
        ///  Default value: 'Authentication was cancelled by the user.'
        /// </summary>
        public static string IAuthenticationBroker_AuthenticationCanceled { get { return @"Authentication was cancelled by the user."; } }
        /// <summary>
        ///  Localized value for IAuthenticationBroker_AuthenticationFailed.
        ///  Default value: 'Authentication failed with HTTP response code {0}.'
        /// </summary>
        public static string IAuthenticationBroker_AuthenticationFailed { get { return @"Authentication failed with HTTP response code {0}."; } }
        /// <summary>
        ///  Localized value for MobileServiceClient_EmptyArgument.
        ///  Default value: '{0} cannot be null, empty or only whitespace.'
        /// </summary>
        public static string MobileServiceClient_EmptyArgument { get { return @"{0} cannot be null, empty or only whitespace."; } }
        /// <summary>
        ///  Localized value for MobileServiceClient_ErrorMessage.
        ///  Default value: 'The request could not be completed.  ({0})'
        /// </summary>
        public static string MobileServiceClient_ErrorMessage { get { return @"The request could not be completed.  ({0})"; } }
        /// <summary>
        ///  Localized value for IAuthenticationBroker_InvalidLoginResponse.
        ///  Default value: 'Invalid format of the authentication response.'
        /// </summary>
        public static string IAuthenticationBroker_InvalidLoginResponse { get { return @"Invalid format of the authentication response."; } }
        /// <summary>
        ///  Localized value for MobileServicesAuthentication_LoginAlreadyInProgress.
        ///  Default value: 'Cannot start a login operation because login is already in progress.'
        /// </summary>
        public static string MobileServicesAuthentication_LoginAlreadyInProgress { get { return @"Cannot start a login operation because login is already in progress."; } }
        /// <summary>
        ///  Localized value for IAuthenticationBroker_LoginFailed.
        ///  Default value: 'Login failed: {0}'
        /// </summary>
        public static string IAuthenticationBroker_LoginFailed { get { return @"Login failed: {0}"; } }
        /// <summary>
        ///  Localized value for MobileServiceTableUrlBuilder_InvalidParameterBeginsWithDollarSign.
        ///  Default value: '{0} is an invalid user-defined query string parameter. User-defined query string parameters must not begin with a \'$\'.'
        /// </summary>
        public static string MobileServiceTableUrlBuilder_InvalidParameterBeginsWithDollarSign { get { return @"{0} is an invalid user-defined query string parameter. User-defined query string parameters must not begin with a \'$\'."; } }
        /// <summary>
        ///  Localized value for MobileServiceTable_InsertWithExistingId.
        ///  Default value: 'Cannot insert if the {0} member is already set.'
        /// </summary>
        public static string MobileServiceTable_InsertWithExistingId { get { return @"Cannot insert if the {0} member is already set."; } }
        /// <summary>
        ///  Localized value for Platform_AssemblyNotFound.
        ///  Default value: 'A Microsoft Azure Mobile Services assembly for the current platform was not found. Ensure that the current project references both {0} and the following platform-specific assembly: {1}.'
        /// </summary>
        public static string Platform_AssemblyNotFound { get { return @"A Microsoft Azure Mobile Services assembly for the current platform was not found. Ensure that the current project references both {0} and the following platform-specific assembly: {1}."; } }
        /// <summary>
        ///  Localized value for Platform_InstantiationFailed.
        ///  Default value: 'Failed to instantiate the platform implementation of {0} from the assembly {1} due to the following error: {2}'
        /// </summary>
        public static string Platform_InstantiationFailed { get { return @"Failed to instantiate the platform implementation of {0} from the assembly {1} due to the following error: {2}"; } }
        /// <summary>
        ///  Localized value for FilterBuildingExpressionVisitor_MemberUnsupported.
        ///  Default value: 'The member '{0}' is not supported in the 'Where' Mobile Services query expression '{1}'.'
        /// </summary>
        public static string FilterBuildingExpressionVisitor_MemberUnsupported { get { return @"The member '{0}' is not supported in the 'Where' Mobile Services query expression '{1}'."; } }
        /// <summary>
        ///  Localized value for FilterBuildingExpressionVisitor_OperatorUnsupported.
        ///  Default value: 'The operator '{0}' is not supported in the 'Where' Mobile Services query expression '{1}'.'
        /// </summary>
        public static string FilterBuildingExpressionVisitor_OperatorUnsupported { get { return @"The operator '{0}' is not supported in the 'Where' Mobile Services query expression '{1}'."; } }
        /// <summary>
        ///  Localized value for FilterBuildingExpressionVisitor_UnsupportedInWhereExpression.
        ///  Default value: ''{0}' is not supported in a 'Where' Mobile Services query expression.'
        /// </summary>
        public static string FilterBuildingExpressionVisitor_UnsupportedInWhereExpression { get { return @"'{0}' is not supported in a 'Where' Mobile Services query expression."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableQueryTranslator_SingleIntegerOnly.
        ///  Default value: ''{0}' Mobile Services query expressions must consist of a single integer, not '{1}'.'
        /// </summary>
        public static string MobileServiceTableQueryTranslator_SingleIntegerOnly { get { return @"'{0}' Mobile Services query expressions must consist of a single integer, not '{1}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableQueryTranslator_MembersOnlyInExpression.
        ///  Default value: ''{0}' Mobile Services query expressions must consist of members only, not '{1}'.'
        /// </summary>
        public static string MobileServiceTableQueryTranslator_MembersOnlyInExpression { get { return @"'{0}' Mobile Services query expressions must consist of members only, not '{1}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableQueryTranslator_UnsupportedExpression.
        ///  Default value: 'Expression '{1}' is not a supported '{0}' Mobile Services query expression.'
        /// </summary>
        public static string MobileServiceTableQueryTranslator_UnsupportedExpression { get { return @"Expression '{1}' is not a supported '{0}' Mobile Services query expression."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableSerializer_CannotDeserializeValue.
        ///  Default value: 'Cannot deserialize value {0} into '{1}.{2}'.'
        /// </summary>
        public static string MobileServiceTableSerializer_CannotDeserializeValue { get { return @"Cannot deserialize value {0} into '{1}.{2}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableSerializer_MissingRequiredMember.
        ///  Default value: 'Cannot deserialize type '{0}' because the JSON object did not have required member(s) '{1}'.'
        /// </summary>
        public static string MobileServiceTableSerializer_MissingRequiredMember { get { return @"Cannot deserialize type '{0}' because the JSON object did not have required member(s) '{1}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableSerializer_NeedObject.
        ///  Default value: 'Expected a JSON object to deserialize, not '{0}'.'
        /// </summary>
        public static string MobileServiceTableSerializer_NeedObject { get { return @"Expected a JSON object to deserialize, not '{0}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableSerializer_UnknownType.
        ///  Default value: 'Cannot serialize member '{0}' of type '{1}' declared on type '{2}'.'
        /// </summary>
        public static string MobileServiceTableSerializer_UnknownType { get { return @"Cannot serialize member '{0}' of type '{1}' declared on type '{2}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceTable_ExpectedArray.
        ///  Default value: 'Could not get an array from response {0}.'
        /// </summary>
        public static string MobileServiceTable_ExpectedArray { get { return @"Could not get an array from response {0}."; } }
        /// <summary>
        ///  Localized value for MobileServiceTable_NotSingleObject.
        ///  Default value: 'Could not get object from response {0}.'
        /// </summary>
        public static string MobileServiceTable_NotSingleObject { get { return @"Could not get object from response {0}."; } }
        /// <summary>
        ///  Localized value for MobileServiceContractResolver_MemberNotFound.
        ///  Default value: 'No '{0}' member found on type '{1}'.'
        /// </summary>
        public static string MobileServiceContractResolver_MemberNotFound { get { return @"No '{0}' member found on type '{1}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceContractResolver_SamePropertyName.
        ///  Default value: 'Only one member may have the property name '{0}' (regardless of casing) on type '{1}'.'
        /// </summary>
        public static string MobileServiceContractResolver_SamePropertyName { get { return @"Only one member may have the property name '{0}' (regardless of casing) on type '{1}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceContractResolver_TypeWithDataMemberButNoDataContract.
        ///  Default value: 'The type '{0}' has one or members with a DataMemberAttribute, but the type itself does not have a DataContractAttribute. Use the Newtonsoft.Json.JsonPropertyAttribute in place of the DataMemberAttribute and set the PropertyName to the desired name.'
        /// </summary>
        public static string MobileServiceContractResolver_TypeWithDataMemberButNoDataContract { get { return @"The type '{0}' has one or members with a DataMemberAttribute, but the type itself does not have a DataContractAttribute. Use the Newtonsoft.Json.JsonPropertyAttribute in place of the DataMemberAttribute and set the PropertyName to the desired name."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_IdNotFound.
        ///  Default value: 'Expected {0} member not found.'
        /// </summary>
        public static string MobileServiceSerializer_IdNotFound { get { return @"Expected {0} member not found."; } }
        /// <summary>
        ///  Localized value for MobileServiceContractResolver_NumberOutOfRange.
        ///  Default value: 'The value {0} for member {1} is outside the valid range for numeric columns.'
        /// </summary>
        public static string MobileServiceContractResolver_NumberOutOfRange { get { return @"The value {0} for member {1} is outside the valid range for numeric columns."; } }
        /// <summary>
        ///  Localized value for MobileServiceContractResolver_TypeNoDataContractButBaseWithDataContract.
        ///  Default value: 'The type '{0}' does not have a DataContractAttribute, but the type derives from the type '{1}', which does have a DataContractAttribute. If a type has a DataContractAttribute, any type that derives from that type must also have a DataContractAttribute.'
        /// </summary>
        public static string MobileServiceContractResolver_TypeNoDataContractButBaseWithDataContract { get { return @"The type '{0}' does not have a DataContractAttribute, but the type derives from the type '{1}', which does have a DataContractAttribute. If a type has a DataContractAttribute, any type that derives from that type must also have a DataContractAttribute."; } }
        /// <summary>
        ///  Localized value for ExpressionUtility_ProjectionNotSupportedOnWindowsPhone75.
        ///  Default value: 'The Linq IQueryable Select() operation is not supported on the Windows Phone 7.5 platform.'
        /// </summary>
        public static string ExpressionUtility_ProjectionNotSupportedOnWindowsPhone75 { get { return @"The Linq IQueryable Select() operation is not supported on the Windows Phone 7.5 platform."; } }
        /// <summary>
        ///  Localized value for MobileServiceClient_NoResponseContent.
        ///  Default value: 'The server did not provide a response with the expected content.'
        /// </summary>
        public static string MobileServiceClient_NoResponseContent { get { return @"The server did not provide a response with the expected content."; } }
        /// <summary>
        ///  Localized value for MobileServiceJsonSerializerSettings_NullOrInvalidContractResolver.
        ///  Default value: 'The member '{0}.ContractResolver' must be set to an instance of the '{1}' class or a class that inherits from the '{1}' class.'
        /// </summary>
        public static string MobileServiceJsonSerializerSettings_NullOrInvalidContractResolver { get { return @"The member '{0}.ContractResolver' must be set to an instance of the '{1}' class or a class that inherits from the '{1}' class."; } }
        /// <summary>
        ///  Localized value for MobileServicePrecisionCheckConverter_ReadNotSupported.
        ///  Default value: 'The {0} does not support reading JSON.'
        /// </summary>
        public static string MobileServicePrecisionCheckConverter_ReadNotSupported { get { return @"The {0} does not support reading JSON."; } }
        /// <summary>
        ///  Localized value for MobileServiceTable_DeleteWithoutId.
        ///  Default value: 'Cannot delete if the {0} member is set to a default value.'
        /// </summary>
        public static string MobileServiceTable_DeleteWithoutId { get { return @"Cannot delete if the {0} member is set to a default value."; } }
        /// <summary>
        ///  Localized value for MobileServiceTable_UpdateWithoutId.
        ///  Default value: 'Cannot update if the {0} member is set to a default value.'
        /// </summary>
        public static string MobileServiceTable_UpdateWithoutId { get { return @"Cannot update if the {0} member is set to a default value."; } }
        /// <summary>
        ///  Localized value for MobileServiceClient_InnerHandlerMustBeNull.
        ///  Default value: 'The 'InnerHandler' property of the delegating handler must be null.'
        /// </summary>
        public static string MobileServiceClient_InnerHandlerMustBeNull { get { return @"The 'InnerHandler' property of the delegating handler must be null."; } }
        /// <summary>
        ///  Localized value for HttpMessageHandlerExtensions_WrongHandlerType.
        ///  Default value: 'All message handlers except the last must be of the type '{0}''
        /// </summary>
        public static string HttpMessageHandlerExtensions_WrongHandlerType { get { return @"All message handlers except the last must be of the type '{0}'"; } }
        /// <summary>
        ///  Localized value for MobileServiceContractResolver_MultipleSystemPropertyAttributes.
        ///  Default value: 'A member can only have one system property attribute. The member '{0}' on type '{1}' has system property attributes '{2}' and '{3}'.'
        /// </summary>
        public static string MobileServiceContractResolver_MultipleSystemPropertyAttributes { get { return @"A member can only have one system property attribute. The member '{0}' on type '{1}' has system property attributes '{2}' and '{3}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceCollection_LoadInProcess.
        ///  Default value: 'Loading of more items already in process.'
        /// </summary>
        public static string MobileServiceCollection_LoadInProcess { get { return @"Loading of more items already in process."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_InvalidIntegerId.
        ///  Default value: 'The integer id '{0}' is not a positive integer value.'
        /// </summary>
        public static string MobileServiceSerializer_InvalidIntegerId { get { return @"The integer id '{0}' is not a positive integer value."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_StringIdTooLong.
        ///  Default value: 'The string id '{0}' is longer than the max string id length of {1} characters.'
        /// </summary>
        public static string MobileServiceSerializer_StringIdTooLong { get { return @"The string id '{0}' is longer than the max string id length of {1} characters."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_LookupInvalidIdType.
        ///  Default value: 'The id parameter type '{0}' is invalid for looking up items of type '{1}'.'
        /// </summary>
        public static string MobileServiceSerializer_LookupInvalidIdType { get { return @"The id parameter type '{0}' is invalid for looking up items of type '{1}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_IdCasingIncorrect.
        ///  Default value: 'The casing of the '{0}' property is invalid.'
        /// </summary>
        public static string MobileServiceSerializer_IdCasingIncorrect { get { return @"The casing of the '{0}' property is invalid."; } }
        /// <summary>
        ///  Localized value for MobileServiceContractResolver_IntegerIdTypeWithSystemPropertyAttributes.
        ///  Default value: 'The type '{0}' has an integer id member and therefore can not have any members with the system property attribute '{1}'.'
        /// </summary>
        public static string MobileServiceContractResolver_IntegerIdTypeWithSystemPropertyAttributes { get { return @"The type '{0}' has an integer id member and therefore can not have any members with the system property attribute '{1}'."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_InvalidStringId.
        ///  Default value: 'The string id '{0}' is invalid. An id must not contain any control characters or the characters "",+,?,\,/,`.'
        /// </summary>
        public static string MobileServiceSerializer_InvalidStringId { get { return @"The string id '{0}' is invalid. An id must not contain any control characters or the characters "",+,?,\,/,`."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_NullOrEmptyStringId.
        ///  Default value: 'The id can not be null or an empty string.'
        /// </summary>
        public static string MobileServiceSerializer_NullOrEmptyStringId { get { return @"The id can not be null or an empty string."; } }
        /// <summary>
        ///  Localized value for MobileServiceSerializer_IdTypeMismatch.
        ///  Default value: 'You might be affected by Mobile Services latest changes to support string Ids. For more details: http://go.microsoft.com/fwlink/?LinkId=330396'
        /// </summary>
        public static string MobileServiceSerializer_IdTypeMismatch { get { return @"You might be affected by Mobile Services latest changes to support string Ids. For more details: http://go.microsoft.com/fwlink/?LinkId=330396"; } }
        /// <summary>
        ///  Localized value for MobileServiceCollection_IncrementalLoadingFailed.
        ///  Default value: 'Failed to incrementally load more items of type '{0}'. See the inner exception for details.'
        /// </summary>
        public static string MobileServiceCollection_IncrementalLoadingFailed { get { return @"Failed to incrementally load more items of type '{0}'. See the inner exception for details."; } }
        /// <summary>
        ///  Localized value for Push_ConflictWithReservedName.
        ///  Default value: 'Template name conflicts with reserved name '{0}'.'
        /// </summary>
        public static string Push_ConflictWithReservedName { get { return @"Template name conflicts with reserved name '{0}'."; } }
        /// <summary>
        ///  Localized value for Push_InvalidTemplateName.
        ///  Default value: 'Template name cannot contain "";"" or "":"".'
        /// </summary>
        public static string Push_InvalidTemplateName { get { return @"Template name cannot contain "";"" or "":""."; } }
        /// <summary>
        ///  Localized value for Push_NotSupportedXMLFormatAsBodyTemplateWin8.
        ///  Default value: 'The bodyTemplate is not in accepted XML format. The first node of the bodyTemplate should be Badge/Tile/Toast, except for the wns/raw template, which needs to be an valid XML.'
        /// </summary>
        public static string Push_NotSupportedXMLFormatAsBodyTemplateWin8 { get { return @"The bodyTemplate is not in accepted XML format. The first node of the bodyTemplate should be Badge/Tile/Toast, except for the wns/raw template, which needs to be an valid XML."; } }
        /// <summary>
        ///  Localized value for Push_BodyTemplateMustBeXml.
        ///  Default value: 'Valid XML is required for any template without a raw header.'
        /// </summary>
        public static string Push_BodyTemplateMustBeXml { get { return @"Valid XML is required for any template without a raw header."; } }
        /// <summary>
        ///  Localized value for Push_BodyTemplateMustContainElement.
        ///  Default value: 'XML must contain an XML node of Element type.'
        /// </summary>
        public static string Push_BodyTemplateMustContainElement { get { return @"XML must contain an XML node of Element type."; } }
        /// <summary>
        ///  Localized value for Push_TagNoCommas.
        ///  Default value: 'Tags must not contain ','.'
        /// </summary>
        public static string Push_TagNoCommas { get { return @"Tags must not contain ','."; } }
        /// <summary>
        ///  Localized value for IAuthenticationBroker_LoginInProgress.
        ///  Default value: 'Authentication is already in progress.'
        /// </summary>
        public static string IAuthenticationBroker_LoginInProgress { get { return @"Authentication is already in progress."; } }
        /// <summary>
        ///  Localized value for IAuthenticationBroker_NoLoginInProgress.
        ///  Default value: 'Authentication has not been started.'
        /// </summary>
        public static string IAuthenticationBroker_NoLoginInProgress { get { return @"Authentication has not been started."; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_IdMustBeString.
        ///  Default value: 'The id must be of type string.'
        /// </summary>
        public static string MobileServiceSyncTable_IdMustBeString { get { return @"The id must be of type string."; } }
        /// <summary>
        ///  Localized value for SyncContext_NotInitialized.
        ///  Default value: 'SyncContext is not yet initialized.'
        /// </summary>
        public static string SyncContext_NotInitialized { get { return @"SyncContext is not yet initialized."; } }
        /// <summary>
        ///  Localized value for SyncStore_FailedToUpsertItem.
        ///  Default value: 'Failed to update the item in the local store.'
        /// </summary>
        public static string SyncStore_FailedToUpsertItem { get { return @"Failed to update the item in the local store."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableQueryDescription_UnrecognizedQueryParameter.
        ///  Default value: 'Unrecognized query parameter '{0}'.'
        /// </summary>
        public static string MobileServiceTableQueryDescription_UnrecognizedQueryParameter { get { return @"Unrecognized query parameter '{0}'."; } }
        /// <summary>
        ///  Localized value for SyncContext_DeletePending.
        ///  Default value: 'A delete operation on the item is already in the queue.'
        /// </summary>
        public static string SyncContext_DeletePending { get { return @"A delete operation on the item is already in the queue."; } }
        /// <summary>
        ///  Localized value for SyncContext_DuplicateInsert.
        ///  Default value: 'An insert operation on the item is already in the queue.'
        /// </summary>
        public static string SyncContext_DuplicateInsert { get { return @"An insert operation on the item is already in the queue."; } }
        /// <summary>
        ///  Localized value for SyncContext_UpdatePending.
        ///  Default value: 'An update operation on the item is already in the queue.'
        /// </summary>
        public static string SyncContext_UpdatePending { get { return @"An update operation on the item is already in the queue."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_UnterminatedStringLiteral.
        ///  Default value: 'The specified odata query has unterminated string literal.'
        /// </summary>
        public static string ODataExpressionParser_UnterminatedStringLiteral { get { return @"The specified odata query has unterminated string literal."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_SyntaxError.
        ///  Default value: 'The specified odata query has syntax errors.'
        /// </summary>
        public static string ODataExpressionParser_SyntaxError { get { return @"The specified odata query has syntax errors."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_DigitExpected.
        ///  Default value: 'Digit expected.'
        /// </summary>
        public static string ODataExpressionParser_DigitExpected { get { return @"Digit expected."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_CloseParenOrCommaExpected.
        ///  Default value: '')' or ',' expected.'
        /// </summary>
        public static string ODataExpressionParser_CloseParenOrCommaExpected { get { return @"')' or ',' expected."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_ExpressionExpected.
        ///  Default value: 'Expression expected.'
        /// </summary>
        public static string ODataExpressionParser_ExpressionExpected { get { return @"Expression expected."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_OpenParenExpected.
        ///  Default value: ''(' expected.'
        /// </summary>
        public static string ODataExpressionParser_OpenParenExpected { get { return @"'(' expected."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_SubstringArgsCount.
        ///  Default value: 'Function 'substring' requires 2 or 3 parameters.'
        /// </summary>
        public static string ODataExpressionParser_SubstringArgsCount { get { return @"Function 'substring' requires 2 or 3 parameters."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_CloseParenOrOperatorExpected.
        ///  Default value: '')' or operator expected'
        /// </summary>
        public static string ODataExpressionParser_CloseParenOrOperatorExpected { get { return @"')' or operator expected"; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_FunctionArgsCount.
        ///  Default value: 'Function '{0}' requires {1} parameter(s).'
        /// </summary>
        public static string ODataExpressionParser_FunctionArgsCount { get { return @"Function '{0}' requires {1} parameter(s)."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_IdentifierExpected.
        ///  Default value: 'Expected identifier.'
        /// </summary>
        public static string ODataExpressionParser_IdentifierExpected { get { return @"Expected identifier."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_IntegerLiteralExpected.
        ///  Default value: 'Expected integer literal.'
        /// </summary>
        public static string ODataExpressionParser_IntegerLiteralExpected { get { return @"Expected integer literal."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_InvalidIntegerLiteral.
        ///  Default value: 'The specified odata query has invalid integer literal '{0}'.'
        /// </summary>
        public static string ODataExpressionParser_InvalidIntegerLiteral { get { return @"The specified odata query has invalid integer literal '{0}'."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_InvalidRealLiteral.
        ///  Default value: 'The specified odata query has invalid real literal '{0}'.'
        /// </summary>
        public static string ODataExpressionParser_InvalidRealLiteral { get { return @"The specified odata query has invalid real literal '{0}'."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_InvalidTypeCreation.
        ///  Default value: 'The specified odata query has invalid '{0}' type creation expression.'
        /// </summary>
        public static string ODataExpressionParser_InvalidTypeCreation { get { return @"The specified odata query has invalid '{0}' type creation expression."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_RealLiteralExpected.
        ///  Default value: 'Expected real literal.'
        /// </summary>
        public static string ODataExpressionParser_RealLiteralExpected { get { return @"Expected real literal."; } }
        /// <summary>
        ///  Localized value for ODataExpressionParser_StringLiteralExpected.
        ///  Default value: 'Expected string literal.'
        /// </summary>
        public static string ODataExpressionParser_StringLiteralExpected { get { return @"Expected string literal."; } }
        /// <summary>
        ///  Localized value for SyncStore_FailedToDeleteOperation.
        ///  Default value: 'Failed to delete operation from the local store.'
        /// </summary>
        public static string SyncStore_FailedToDeleteOperation { get { return @"Failed to delete operation from the local store."; } }
        /// <summary>
        ///  Localized value for SyncStore_FailedToReadItem.
        ///  Default value: 'Failed to read the item from local store.'
        /// </summary>
        public static string SyncStore_FailedToReadItem { get { return @"Failed to read the item from local store."; } }
        /// <summary>
        ///  Localized value for SyncStore_FailedToLoadError.
        ///  Default value: 'Failed to read errors from the local store.'
        /// </summary>
        public static string SyncStore_FailedToLoadError { get { return @"Failed to read errors from the local store."; } }
        /// <summary>
        ///  Localized value for SyncStore_FailedToDeleteError.
        ///  Default value: 'Failed to delete error from the local store.'
        /// </summary>
        public static string SyncStore_FailedToDeleteError { get { return @"Failed to delete error from the local store."; } }
        /// <summary>
        ///  Localized value for SyncStore_OperationFailed.
        ///  Default value: 'Failed to perform operation on local store.'
        /// </summary>
        public static string SyncStore_OperationFailed { get { return @"Failed to perform operation on local store."; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_PullWithSelectNotSupported.
        ///  Default value: 'Pull query with select clause is not supported.'
        /// </summary>
        public static string MobileServiceSyncTable_PullWithSelectNotSupported { get { return @"Pull query with select clause is not supported."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableOperation_ItemNotFound.
        ///  Default value: 'Operation must have an item associated with it.'
        /// </summary>
        public static string MobileServiceTableOperation_ItemNotFound { get { return @"Operation must have an item associated with it."; } }
        /// <summary>
        ///  Localized value for MobileServiceTable_ItemNotFoundInStore.
        ///  Default value: 'Item not found in local store.'
        /// </summary>
        public static string MobileServiceTable_ItemNotFoundInStore { get { return @"Item not found in local store."; } }
        /// <summary>
        ///  Localized value for MobileServiceTableOperation_ResultNotJObject.
        ///  Default value: 'Mobile Service table operation returned an unexpected response.'
        /// </summary>
        public static string MobileServiceTableOperation_ResultNotJObject { get { return @"Mobile Service table operation returned an unexpected response."; } }
        /// <summary>
        ///  Localized value for SyncStore_NotInitialized.
        ///  Default value: 'The store must be initialized before it can be used.'
        /// </summary>
        public static string SyncStore_NotInitialized { get { return @"The store must be initialized before it can be used."; } }
        /// <summary>
        ///  Localized value for SyncStore_AlreadyInitialized.
        ///  Default value: 'The store is already initialized.'
        /// </summary>
        public static string SyncStore_AlreadyInitialized { get { return @"The store is already initialized."; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_InvalidQueryId.
        ///  Default value: 'The query id must not contain pipe character and should be less than 50 characters in length.'
        /// </summary>
        public static string MobileServiceSyncTable_InvalidQueryId { get { return @"The query id must not contain pipe character and should be less than 50 characters in length."; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_IncrementalPullWithOrderNotAllowed.
        ///  Default value: 'Incremental pull query must not have orderby clause.'
        /// </summary>
        public static string MobileServiceSyncTable_IncrementalPullWithOrderNotAllowed { get { return @"Incremental pull query must not have orderby clause."; } }
        /// <summary>
        ///  Localized value for SyncStore_FailedToUpdateOperation.
        ///  Default value: 'Failed to update operation in the local store.'
        /// </summary>
        public static string SyncStore_FailedToUpdateOperation { get { return @"Failed to update operation in the local store."; } }
        /// <summary>
        ///  Localized value for SyncError_OperationUpdated.
        ///  Default value: 'The operation has been updated and cannot be cancelled.'
        /// </summary>
        public static string SyncError_OperationUpdated { get { return @"The operation has been updated and cannot be cancelled."; } }
        /// <summary>
        ///  Localized value for SyncContext_PurgeOnDirtyTable.
        ///  Default value: 'The table cannot be purged because it has pending operations.'
        /// </summary>
        public static string SyncContext_PurgeOnDirtyTable { get { return @"The table cannot be purged because it has pending operations."; } }
        /// <summary>
        ///  Localized value for SyncContext_InsertAttempted.
        ///  Default value: 'The item is in inconsistent state in the local store. Please complete the pending sync by calling PushAsync()before deleting the item.'
        /// </summary>
        public static string SyncContext_InsertAttempted { get { return @"The item is in inconsistent state in the local store. Please complete the pending sync by calling PushAsync()before deleting the item."; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_IncrementalPullWithSkipTopNotSupported.
        ///  Default value: 'Incremental pull query must not have skip or top specified.'
        /// </summary>
        public static string MobileServiceSyncTable_IncrementalPullWithSkipTopNotSupported { get { return @"Incremental pull query must not have skip or top specified."; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_SkipNotAllowed.
        ///  Default value: 'The supported table options does not include skip. '
        /// </summary>
        public static string MobileServiceSyncTable_SkipNotAllowed { get { return @"The supported table options does not include skip. "; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_TopNotAllowed.
        ///  Default value: 'The supported table options does not include top.'
        /// </summary>
        public static string MobileServiceSyncTable_TopNotAllowed { get { return @"The supported table options does not include top."; } }
        /// <summary>
        ///  Localized value for MobileServiceSyncTable_OrderByNotAllowed.
        ///  Default value: 'The supported table options does not include orderby.'
        /// </summary>
        public static string MobileServiceSyncTable_OrderByNotAllowed { get { return @"The supported table options does not include orderby."; } }
        /// <summary>
        ///  Localized value for MobileServiceTable_QueryUriHostIsDifferent.
        ///  Default value: 'The query uri must be on the same host as the Mobile Service.'
        /// </summary>
        public static string MobileServiceTable_QueryUriHostIsDifferent { get { return @"The query uri must be on the same host as the Mobile Service."; } }
        /// <summary>
        ///  Localized value for WP8LoginPage_MustBeCalledFromAuthBroker.
        ///  Default value: 'This page must be called from the type '{0}'.'
        /// </summary>
        public static string WP8LoginPage_MustBeCalledFromAuthBroker { get { return @"This page must be called from the type '{0}'."; } }
        /// <summary>
        ///  Localized value for Pull_Cannot_Use_Reserved_Key.
        ///  Default value: 'The key '{0}' is reserved and cannot be specified as a query parameter.'
        /// </summary>
        public static string Pull_Cannot_Use_Reserved_Key { get { return @"The key '{0}' is reserved and cannot be specified as a query parameter."; } }
        /// <summary>
        ///  Localized value for Push_Failure.
        ///  Default value: 'Push operation has failed. See the PushResult for details.'
        /// </summary>
        public static string Push_Failure { get { return @"Push operation has failed. See the PushResult for details."; } }

    }
}


text:
Directory Contents
------------------
*  ./analysis/: Lab write-up
*  ./input/: input text files to be evaluated
*  ./output/: output text files from runs against the included input
*  ./src/: raw and compiled source java code, long with Makefile for testing, compilation, documentation
*  ./src/docs/: java autodoc output

Compilation/Batch Running
-------------------------
The src directory contains a Makefile to clean the directory, run the compile the code, run the tests, produce documentation, and finally pass the available input through the evaluator.

Note that the JUnit library is required to run the unittests.  If JUnit is not installed, "make nounittest" should be run to avoid that section of the code.

Makefile usage is outlined below.
```bash
make             # run the entire suite
make nounittest  # run the entire suite without the JUnit unittest framework
make compile     # compile the source
make unittest    # compile and tun the unit tests with the JUnit framework
make clean       # clean up all output files
make timing      # run all the sorting methods and output to timing files
make doc         # generate documentation
make lab         # run the code against the input files
```

Individual Usage
-----
```java
java Driver inputFile outputFile sortingMethod
```
Sorting method can be any of: insertion, heap, heaprecursive, quick, quickmed.  For quick and quickmed, a 4th optional arguemtn can be supplied to indicate the minumum partition size to employ insertion sort.

Example Usage
------
```java
java Driver ../inputs/random_50.txt ../output/random_50.txt heap
java Driver ../inputs/order_500.txt ../output/tmp.txt quick 50
```

redpajama_set_name: RedPajamaGithub


text:
module Chess.Notation (
  -- * Reading basic chess data
  readsPiece, readsPiece', readsSquare, readsFile, readsRank,
  -- * Showing basic chess data
  showsPiece, showsPiece', showsSquare, showsFile, showsRank,
  -- * The 'SANMove' type
  SANMove(..), move2san, move2san', san2move,
  -- * Reading & showing moves
  readsSAN, readsMove,
  showsSAN, showsMove,
 ) where
 import Control.Monad (guard, liftM2)
 import Data.Array
 import Data.Char (toLower, intToDigit, isSpace)
 import Data.Maybe (isJust, maybeToList, fromJust)
 import Text.ParserCombinators.ReadP
 import Chess
 import Chess.Util

 -- |A representation of the possible information that can be encoded in a
 -- standard algebraic notation move
 data SANMove = SANMove {
  sm_shortCastle :: Bool,
  sm_longCastle  :: Bool,
  sm_piece       :: Piece,
  sm_fromFile    :: Maybe File,
  sm_fromRank    :: Maybe Rank,
  sm_capture     :: Bool,
  sm_to          :: Maybe Square,  -- 'Nothing' iff the move is a castle
  sm_passant     :: Bool,
  sm_promotion   :: Maybe Piece,
  sm_checks      :: Bool,
  sm_checkmates  :: Bool
 } deriving (Eq, Ord, Read, Show)

 -- |'ShowS' for converting a 'SANMove' to standard algebraic notation
 showsSAN :: SANMove -> ShowS
 showsSAN sm = if sm_shortCastle sm then showString "0-0"
	       else if sm_longCastle sm then showString "0-0-0"
	       else showsPiece (sm_piece sm)
		     . (sm_piece sm == Pawn
		        ?: (sm_capture sm
			    ?: maybe id showsFile (sm_fromFile sm) . ('x' :)
			    :? id)
			:? maybe id showsFile (sm_fromFile sm)
			 . maybe id showsRank (sm_fromRank sm)
			 . (sm_capture sm ?: ('x' :) :? id))
		     . showsSquare (fromJust $ sm_to sm)
		     . (sm_passant sm ?: showString "e.p." :? id)
		     . maybe id showsPiece (sm_promotion sm)

 readsSAN :: ReadS SANMove  -- read a SAN or PGN move
 readsSAN = readP_to_S $ do
  -- TODO: Should this support check(mate) indicators before _en passant_
  -- indicators?
  skipSpaces
  sm <- read00 +++ read000 +++ readNorm
  (skipSpaces >> char '+' >> return (sm {sm_checks = True}))
   +++ (skipSpaces >> (string "#" +++ string "++") >> return (sm {sm_checkmates = True}))
   +++ return sm
  where read00 = string "0-0" +++ string "O-O" >> return (SANMove True False King Nothing Nothing False Nothing False Nothing False False)
	read000 = string "0-0-0" +++ string "O-O-O" >> return (SANMove False True King Nothing Nothing False Nothing False Nothing False False)
	readNorm = do piece <- readS_to_P readsPiece
		      f1 <- optional' $ readS_to_P readsFile
		      r1 <- optional' $ readS_to_P readsRank
		      capt <- option' $ char 'x'
		      to <- readS_to_P readsSquare
		      ep <- option' $ skipSpaces >> string "e.p." >> skipSpaces
		      promo <- optional' $ optional (char '=')
					    >> readS_to_P readsPiece
		      guard $ promo /= Just Pawn && promo /= Just King
		      return $ SANMove False False piece f1 r1 capt (Just to)
				       ep promo False False

 -- |'ShowS' for a 'Piece' in English-based algebraic notation.  Pieces are
 -- represented as uppercase letters, except 'Pawn', which is represented by an
 -- empty string.
 showsPiece :: Piece -> ShowS
 showsPiece King   = ('K' :)
 showsPiece Queen  = ('Q' :)
 showsPiece Bishop = ('B' :)
 showsPiece Knight = ('N' :)
 showsPiece Rook   = ('R' :)
 showsPiece Pawn   = id

 -- |'ShowS' for a 'Piece' with 'Player' information, with white's pieces being
 -- written in uppercase and black's in lowercase.  'Pawn's are explicitly
 -- written as @P@ or @p@.
 showsPiece' :: (Piece, Player) -> ShowS
 showsPiece' (p, side) = ((side == White ?: id :? toLower) (short ! p) :)
  where short = listArray (Pawn, King) "PRNBQK"

 -- |'ReadS' for a 'Piece' in English-based algebraic notation.  'Pawn' is
 -- represented by an empty string and is returned if & only if none of the
 -- other options matched.  Matches must be in uppercase.  Leading whitespace
 -- is skipped.
 readsPiece :: ReadS Piece
 readsPiece str = case dropWhile isSpace str of
		   'K':xs -> [(King,   xs)]
		   'Q':xs -> [(Queen,  xs)]
		   'B':xs -> [(Bishop, xs)]
		   'N':xs -> [(Knight, xs)]
		   'R':xs -> [(Rook,   xs)]
		   xs     -> [(Pawn,   xs)]

 -- |'ReadS' for a 'Piece' with 'Player' information in which white's pieces
 -- are written in uppercase and black's in lowercase.  'Pawn's must be
 -- explicitly written as @P@ or @p@.  Leading whitespace is skipped.
 readsPiece' :: ReadS (Piece, Player)
 readsPiece' str = case dropWhile isSpace str of
		    'K':xs -> [((King,   White), xs)]
		    'Q':xs -> [((Queen,  White), xs)]
		    'B':xs -> [((Bishop, White), xs)]
		    'N':xs -> [((Knight, White), xs)]
		    'R':xs -> [((Rook,   White), xs)]
		    'P':xs -> [((Pawn,   White), xs)]
		    'k':xs -> [((King,   Black), xs)]
		    'q':xs -> [((Queen,  Black), xs)]
		    'b':xs -> [((Bishop, Black), xs)]
		    'n':xs -> [((Knight, Black), xs)]
		    'r':xs -> [((Rook,   Black), xs)]
		    'p':xs -> [((Pawn,   Black), xs)]
		    _      -> []

 -- |'ShowS' for a 'Square' represented as a 'File' (as shown by 'showsFile')
 -- followed by a 'Rank' (as shown by 'showsRank').
 showsSquare :: Square -> ShowS
 showsSquare (f,r) = showsFile f . showsRank r

 -- |'ReadS' for a 'Square' represented as a 'File' (as read by 'readsFile')
 -- followed by a 'Rank' (as read by 'readsRank').  Leading and intervening
 -- whitespace is skipped.
 readsSquare :: ReadS Square
 readsSquare txt = do (x, r1) <- readsFile txt
		      (y, r2) <- readsRank r1
		      return ((x,y), r2)

 -- |'ShowS' for a 'File' represented as a lowercase letter from @a@ to @h@
 showsFile :: File -> ShowS
 showsFile f = (toEnum (fromEnum f + 97) :)

 -- |'ReadS' for a 'File' represented as a letter from @a@ to @h@.  Matches are
 -- case-insensitive.  Leading whitespace is skipped.
 readsFile :: ReadS File
 readsFile str = case dropWhile isSpace str of
		  'a':xs -> [(FileA, xs)]
		  'A':xs -> [(FileA, xs)]
		  'b':xs -> [(FileB, xs)]
		  'B':xs -> [(FileB, xs)]
		  'c':xs -> [(FileC, xs)]
		  'C':xs -> [(FileC, xs)]
		  'd':xs -> [(FileD, xs)]
		  'D':xs -> [(FileD, xs)]
		  'e':xs -> [(FileE, xs)]
		  'E':xs -> [(FileE, xs)]
		  'f':xs -> [(FileF, xs)]
		  'F':xs -> [(FileF, xs)]
		  'g':xs -> [(FileG, xs)]
		  'G':xs -> [(FileG, xs)]
		  'h':xs -> [(FileH, xs)]
		  'H':xs -> [(FileH, xs)]
		  _      -> []

 -- |'ShowS' for a 'Rank' represented as a digit from @1@ to @8@
 showsRank :: Rank -> ShowS
 showsRank = (:) . intToDigit . succ . fromEnum

 -- |'ReadS' for a 'Rank' represented as a digit from @1@ to @8@.  Leading
 -- whitespace is skipped.
 readsRank :: ReadS Rank
 readsRank str = case dropWhile isSpace str of
		  '1':xs -> [(Rank1, xs)]
		  '2':xs -> [(Rank2, xs)]
		  '3':xs -> [(Rank3, xs)]
		  '4':xs -> [(Rank4, xs)]
		  '5':xs -> [(Rank5, xs)]
		  '6':xs -> [(Rank6, xs)]
		  '7':xs -> [(Rank7, xs)]
		  '8':xs -> [(Rank8, xs)]
		  _      -> []

 move2san :: Move -> SANMove
 -- fills in sm_from* only as little as necessary to eliminate ambiguity
 move2san m = SANMove {
  sm_shortCastle = m_isShortCastle m,
  sm_longCastle  = m_isLongCastle m,
  sm_piece       = m_piece m,
  sm_fromFile    = frF,
  sm_fromRank    = frR,
  sm_capture     = isJust $ m_captured m,
  sm_to          = Just $ m_to m,
  sm_passant     = m_isEnPassant m,
  sm_promotion   = m_promoted m,
  sm_checks      = m_checks m,
  sm_checkmates  = m_checkmates m
 } where (frF, frR) = if m_piece m == Pawn
			   then (m_captured m >> return f, Nothing)
		      else if length fs == 1
			   then (Nothing, Nothing)
		      else case (filter (== f) fs, filter (== r) rs) of
				([_], _) -> (Just f,  Nothing)
				(_, [_]) -> (Nothing, Just r)
				_        -> (Just f,  Just r)
	 (f,  r)  = m_from m
	 (fs, rs) = unzip $ map m_from $ pieceTo (m_before m) (m_piece m)
						 (m_to m)

 move2san' :: Move -> SANMove  -- fills in sm_from* completely
 move2san' m = SANMove {
  sm_shortCastle = m_isShortCastle m,
  sm_longCastle  = m_isLongCastle m,
  sm_piece       = m_piece m,
  sm_fromFile    = Just $ fst $ m_from m,
  sm_fromRank    = Just $ snd $ m_from m,
  sm_capture     = isJust $ m_captured m,
  sm_to          = Just $ m_to m,
  sm_passant     = m_isEnPassant m,
  sm_promotion   = m_promoted m,
  sm_checks      = m_checks m,
  sm_checkmates  = m_checkmates m
 }

 san2move :: Board -> SANMove -> [Move]
 san2move game sm = case (sm_shortCastle sm, sm_longCastle sm, sm_to sm) of
  (True,  False, _)       -> maybeToList $ shortCastle game
  (False, True,  _)       -> maybeToList $ longCastle  game
  (False, False, Just to) -> do
   move <- pieceTo game (sm_piece sm) to
   guard $ maybe True (fst (m_from move) ==) (sm_fromFile sm)
   guard $ maybe True (snd (m_from move) ==) (sm_fromRank sm)
   guard $ liftM2 (==) (sm_promotion sm) (m_promoted move) /= Just False
   return move
   -- TODO: When promotions are given for non-promotional moves, should the
   -- conversion fail?
   -- TODO: When promotions are omitted for promotional moves, should only
   -- promotion to Queen be returned?
  _ -> []

 showsMove :: Move -> ShowS
 showsMove = showsSAN . move2san

 readsMove :: Board -> ReadS Move
 readsMove game str = do (san, r1) <- readsSAN str
			 move <- san2move game san
			 return (move, r1)


text:
var Aria = require("../Aria");
var ariaUtilsType = require("../utils/Type");
var ariaUtilsJson = require("../utils/Json");

/**
 * Common class for all elements supporting a disabled attribute
 */
module.exports = Aria.classDefinition({
    $classpath : "aria.html.DisabledTrait",
    $prototype : {

        /**
         * Initialize the disabled attribute of the widget by taking into account the data model to which it might be
         * bound.
         */
        initDisabledWidgetAttribute : function () {
            var bindings = this._cfg.bind;
            var binding = bindings.disabled;
            if (binding) {
                var newValue = this._transform(binding.transform, binding.inside[binding.to], "toWidget");
                if (ariaUtilsType.isBoolean(newValue)) {
                    this._domElt.disabled = newValue;
                } else {
                    ariaUtilsJson.setValue(binding.inside, binding.to, this._domElt.disabled);
                }
            }
        },

        /**
         * Function called when a value inside 'bind' has changed. It only deals with the case in which the bound
         * property is 'disabled'
         * @param {String} name Name of the property
         * @param {Object} value Value of the changed property
         * @param {Object} oldValue Value of the property before the change happened
         */
        onDisabledBind : function (name, value, oldValue) {
            if (name === "disabled") {
                this._domElt.disabled = value;
            }
        }

    }
});


text:
// Code generated by client-gen. DO NOT EDIT.

package v1

type SnatGlobalInfoExpansion interface{}


text:
import threading
import sensors
import satTLE
import time
import stepperControl
from Queue import Queue

def rotate_antenna():
    serial_port = sensors.init_GPS('/dev/ttyAMA0', 38400)
    i2c = sensors.init_compass(0, 0x1d)
    q = Queue()

    t_gps = threading.Thread(target=sensors.read_GPS, args=(serial_port, q,))
    t_gps.start()

    sat_name = raw_input("Please enter the exact satellite name: ")
    # Testing
    # make a new satellite
    TLE = satTLE.loadTLE()
    ISS = satTLE.Satellite('ISS', TLE[sat_name])
    location = satTLE.Observer(-37.97357, 145.01636, 120)

    # Make the stepper
    azimuth_stepper = stepperControl.Stepper(11, 12, 0.001, 27 * 200/360.0)
    elevation_stepper = stepperControl.Stepper(15, 16, 0.001, 27 * 200/360.0)

    while True:

        satLLA, satCoords = ISS.LLAcoordinates(0)
        azimuth, elevation = location.getAzEl(satLLA, satCoords)

        real_azimuth = sensors.read_compass(i2c)
        # Register that we want to move
        azimuth_stepper.rotate_to_angle(azimuth, real_azimuth)
        elevation_stepper.rotate_to_angle(elevation)

        # Now step both motors
        if azimuth_stepper.has_steps():
            while azimuth_stepper.step():
                pass

        if elevation_stepper.has_steps():
            while elevation_stepper.step():
                pass

        time.sleep(1)

if __name__ == '__main__':
    rotate_antenna()


text:
package io.vertigo.stella.work;

import io.vertigo.app.Home;
import io.vertigo.core.component.di.injector.DIInjector;
import io.vertigo.lang.Assertion;
import io.vertigo.util.ClassUtil;

/**
 * Provider des taches.
 * Ce provider définit le moyen dont la tache doit être exécuter.
 * Dans la plupart des cas le moyen est une classe.
 * Dans certain cs il peut s'agir du nom de la classe.
 * @author  pchretien
 * @param <R> result
 * @param <W> work
 */
public final class WorkEngineProvider<R, W> {
	private final String className;
	private final Class<? extends WorkEngine<R, W>> clazz;
	private final WorkEngine<R, W> workEngine;

	/**
	 * Constructor.
	 * @param clazz Workengine class
	 */
	public WorkEngineProvider(final Class<? extends WorkEngine<R, W>> clazz) {
		Assertion.checkNotNull(clazz);
		//-----
		this.clazz = clazz;
		this.className = clazz.getName();
		this.workEngine = null;
	}

	/**
	 * Constructor.
	 * @param workEngine Workengine instance
	 */
	public WorkEngineProvider(final WorkEngine<R, W> workEngine) {
		Assertion.checkNotNull(workEngine);
		//-----
		this.workEngine = workEngine;
		this.clazz = null;
		this.className = workEngine.getClass().getName();
	}

	/**
	 * Constructor.
	 * @param className Workengine class name
	 */
	public WorkEngineProvider(final String className) {
		Assertion.checkArgNotEmpty(className);
		//-----
		this.className = className;
		this.clazz = null;
		this.workEngine = null;
	}

	/**
	 * @return WorkEngine
	 */
	public WorkEngine<R, W> provide() {
		if (workEngine != null) {
			return workEngine;
		}
		final Class<? extends WorkEngine<R, W>> engineClazz;
		if (clazz != null) {
			engineClazz = clazz;
		} else {
			engineClazz = (Class<? extends WorkEngine<R, W>>) ClassUtil.classForName(className);
		}
		//récupéartion de l'engine par sa classe.
		return DIInjector.newInstance(engineClazz, Home.getApp().getComponentSpace());
	}

	/**
	 * @return WorkEngine name
	 */
	public String getName() {
		return className;
	}

}


text:
module Telesign
  module PhoneVerification
    class Request < ApiRequest

      attr_accessor :country_code, :phone_number, :delay_time, :radial_count,
                    :extension_content, :extension_type, :call_type, :caller_id, :priority,
                    :message, :project, :additional, :verification_code

      alias_method :countryCode, :country_code
      alias_method :phoneNumber, :phone_number
      alias_method :delayTime, :delay_time
      alias_method :redialCount, :radial_count
      alias_method :extensionContent, :extension_content
      alias_method :extensionType, :extension_type
      alias_method :callType, :call_type
      alias_method :callerID, :caller_id
      alias_method :verificationCode, :verification_code

      def initialize(phone)
        self.phone_number = phone.number
        self.country_code = phone.country_code
      end
    end
  end
end


text:
import os, sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

from flask_blog import app
import sqlalchemy

db_uri = 'mysql://%s:%s@mysql:3306/' % (app.config['DB_USERNAME'], app.config['DB_PASSWORD'])
engine = sqlalchemy.create_engine(db_uri)
conn = engine.connect()
conn.execute("commit")
#conn.execute('SET FOREIGN_KEY_CHECKS = 0;')
#conn.execute("DROP DATABASE " + app.config['BLOG_DATABASE_NAME'])
conn.execute("CREATE DATABASE " + app.config['BLOG_DATABASE_NAME'])
conn.close()

'''
Adding
SET FOREIGN_KEY_CHECKS = 0;
before dropping a database fixes the foreign key constraint problem (as introduced in 4.0.18) for me
'''


text: export {default} from 'ember-frost-bunsen/components/section'


text:
#pragma once

#include <string>

namespace hulo {

extern std::string trim(std::string s);
extern std::string stringTok(std::string &in);

}


text:
FROM ubuntu:latest AS builder

ARG CLN_VERSION=v0.12.1

WORKDIR /tmp

RUN apt-get update \
 && apt-get install --yes --no-install-recommends \
    autoconf \
    automake \
    build-essential \
    gettext \
    git \
    gnupg \
    libgmp-dev \
    libsodium-dev \
    libsqlite3-dev \
    libtool \
    net-tools \
    python3 \
    python3-dev \
    python3-pip \
    zlib1g-dev

RUN pip3 install \
    mako \
    mistune==0.8.4 \
    mrkd \
    poetry

RUN git clone --depth 1 --branch ${CLN_VERSION} https://github.com/ElementsProject/lightning.git

WORKDIR /tmp/lightning

COPY developer_pubkey.pem .

RUN gpg --import developer_pubkey.pem \
 && git verify-tag ${CLN_VERSION}

RUN poetry install

ENV LDFLAGS="-s"

RUN ./configure \
    --enable-experimental-features \
    --enable-static

RUN make -j$(nproc)

RUN make install

FROM ubuntu:latest

COPY --from=builder /usr/local/bin/lightning* /usr/local/bin/
COPY --from=builder /usr/local/libexec        /usr/local/libexec

CMD ["/usr/local/bin/lightningd"]


text:
package org.autonomous4j.control;

import org.autonomous4j.interfaces.A4jBrain3D;
import com.dronecontrol.droneapi.DroneController;
import com.dronecontrol.droneapi.ParrotDroneController;
import com.dronecontrol.droneapi.commands.composed.PlayLedAnimationCommand;
import com.dronecontrol.droneapi.data.Config;
import com.dronecontrol.droneapi.data.LoginData;
import com.dronecontrol.droneapi.data.enums.LedAnimation;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.autonomous4j.listeners.xyz.A4jErrorListener;
import org.autonomous4j.listeners.xyz.A4jNavDataListener;
import org.autonomous4j.listeners.xyz.A4jReadyStateChangeListener;
import org.autonomous4j.listeners.xyz.A4jVideoDataListener;
import org.autonomous4j.tracking.A4jBlackBox;
import org.autonomous4j.tracking.A4jBlackBox.Movement;

/**
 *
 * @author Mark Heckler (mark.heckler@gmail.com, @mkheck)
 */
public class A4jBrainA implements A4jBrain3D {
    private static final A4jBrainA brain = new A4jBrainA();
    private DroneController controller;
    private Config cfg;
    //private NavData currentNav;
    private final A4jBlackBox recorder;
    private boolean isRecording;

    private A4jBrainA() {
        cfg = new Config("Autonomous4j Test", "My Profile", 0);
        this.recorder = new A4jBlackBox();
        isRecording = true;
    }

    public static A4jBrainA getInstance() {
        return brain;
    }

    @Override
    public boolean connect() {
        return connect("192.168.1.1");
    }

    public boolean connect(String ipAddress) {
        try {
            controller = ParrotDroneController.build();
            //cfg = new Config("Autonomous4j Test", "My Profile", 0);
            controller.start(cfg);

            //controller.addVideoDataListener(new A4jVideoDataListener());
            controller.addNavDataListener(new A4jNavDataListener());
            controller.addReadyStateChangeListener(new A4jReadyStateChangeListener());
            controller.addErrorListener(new A4jErrorListener());
        } catch (Exception ex) {
            System.err.println("Exception creating new drone connection: " + ex.getMessage());
            return false;
        }
        return true;
    }

    @Override
    public void disconnect() {
        if (controller != null) {
            controller.stop();
        }
        recorder.shutdown();
    }

    /**
     * Convenience (pass-through) method for more fluent API.
     * @param ms Long variable specifying a number of milliseconds.
     * @return A4jBrainA object (allows command chaining/fluency.
     * @see #hold(long)
     */
    @Override
    public A4jBrainA doFor(long ms) {
        return hold(ms);
    }

    @Override
    public A4jBrainA hold(long ms) {
        System.out.println("Hold for " + ms + " milliseconds...");
        try {
            Thread.sleep(ms);
            if (isRecording) {
                recorder.recordDuration(ms);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Logger.getLogger(A4jBrainA.class.getName()).log(Level.SEVERE, null, e);
        }

        return this;
    }

    @Override
    public A4jBrainA stay() {
        return hover();
    }

    @Deprecated
    public A4jBrainA hover() {
        System.out.println("--Hover--");
        controller.move(0, 0, 0, 0);
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.STAY);
        }

        return this;
    }

    public void land() {
        System.out.println("Land.");
        controller.land();
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.LAND);
        }
    }

    public A4jBrainA takeoff() {
        System.out.println("Takeoff!");
        controller.takeOff();
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.TAKEOFF);
        }

        return this;
    }

    @Override
    public A4jBrainA forward() {
        return forward(100);
    }

    public A4jBrainA forward(int speed) {
        System.out.println("Forward @" + speed);
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.FORWARD, speed);
        }

        return move(0f, -perc2float(speed), 0f, 0f);
    }

    @Override
    public A4jBrainA backward() {
        return backward(100);
    }

    public A4jBrainA backward(int speed) {
        System.out.println("Backward @" + speed);
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.BACKWARD, speed);
        }

        return move(0f, perc2float(speed), 0f, 0f);
    }

//  MAH: will need to revisit this to accommodate either 90 degree turns ONLY or odd angles.
//    public A4jBrainA spinRight(int speed) {
//        System.out.println("spinRight @" + speed);
//        //recorder.recordAction(A4jBlackBox.Action.FORWARD);
//
//        return move(0f, 0f, 0f, perc2float(speed));
//    }
//
//    public A4jBrainA spinLeft(int speed) {
//        System.out.println("spinLeft @" + speed);
//        return move(0f, 0f, 0f, -perc2float(speed));
//    }

    @Override
    public A4jBrain3D up() {
        return up(100);
    }

    public A4jBrainA up(int speed) {
        System.out.println("up @" + speed);
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.UP, speed);
        }

        return move(0f, 0f, perc2float(speed), 0f);
    }

    @Override
    public A4jBrain3D down() {
        return down(100);
    }

    public A4jBrainA down(int speed) {
        System.out.println("down @" + speed);
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.DOWN, speed);
        }

        return move(0f, 0f, -perc2float(speed), 0f);
    }

    public A4jBrainA goRight(int speed) {
        System.out.println("goRight @" + speed);
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.RIGHT, speed);
        }

        return move(perc2float(speed), 0f, 0f, 0f);
    }

    public A4jBrainA goLeft(int speed) {
        System.out.println("goLeft @" + speed);
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.LEFT, speed);
        }

        return move(-perc2float(speed), 0f, 0f, 0f);
    }

    public A4jBrainA playLedAnimation(float frequency, int durationSeconds) {
        // "Default" LED animation sequence is blank for now
        playLedAnimation(LedAnimation.BLANK, frequency, durationSeconds);
        return this;
    }

    public A4jBrainA playLedAnimation(LedAnimation animation, float frequency, int durationSeconds) {
        if (isRecording) {
            recorder.recordAction(A4jBlackBox.Action.LIGHTS, (int) frequency);
        }
        controller.executeCommandsAsync(
                new PlayLedAnimationCommand(cfg.getLoginData(),
                        animation, frequency, durationSeconds));
//        controller.executeCommands(
//                new PlayLedAnimationCommand(cfg.getLoginData(),
//                        animation, frequency, durationSeconds));
        hold(durationSeconds * 1000);
        System.out.println("Blinking " + animation.name() + ", Frequency: " +
            frequency + " for " + durationSeconds + " seconds.");
        return this;
    }

    @Override
    public A4jBrainA goHome() {
        processRecordedMovements(recorder.home());
        return this;
    }

    @Override
    public A4jBrainA replay() {
        processRecordedMovements(recorder.getRecording());
        return this;
    }

    @Override
    public A4jBrainA left() {
        //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        System.out.println("Turn to the left.");
        return this;
    }

    @Override
    public A4jBrainA right() {
        //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        System.out.println("Turn to the right.");
        return this;
    }

    @Override
    public void processRecordedMovements(List<Movement> moves) {
        // Disable recording for playback
        isRecording = false;

        for (Movement curMov : moves) {
            switch(curMov.getAction()) {
                case FORWARD:
                    forward(curMov.getSpeed());
                    break;
                case BACKWARD:
                    backward(curMov.getSpeed());
                    break;
                case RIGHT:
                    goRight(curMov.getSpeed());
                    break;
                case LEFT:
                    goLeft(curMov.getSpeed());
                    break;
                case UP:
                    up(curMov.getSpeed());
                    break;
                case DOWN:
                    down(curMov.getSpeed());
                    break;
                case STAY:
                    stay();
                    break;
                case TAKEOFF:
                    takeoff();
                    break;
                case LAND:
                    land();
                    break;
                case LIGHTS:
                    playLedAnimation(curMov.getSpeed(), (int) curMov.getDuration()/1000);
                    break;
            }
            hold(curMov.getDuration());
            System.out.println(curMov);
        }

        // Re-enable recording
        isRecording = true;
    }

    private float limit(float f, float min, float max) {
        return (f > max ? max : (f < min ? min : f));
    }

    public A4jBrainA move(float roll ,float pitch, float gaz, float yaw) {
        roll = limit(roll, -1f, 1f);
        pitch = limit(pitch, -1f, 1f);
        gaz = limit(gaz, -1f, 1f);
        yaw = limit(yaw, -1f, 1f);

        controller.move(roll, pitch, yaw, gaz);

        return this;
    }

    private float perc2float(int speed) {
        return (float) (speed / 100.0f);
    }
}


text:
var perf_hooks = {};
try { perf_hooks = require("perf_hooks"); } catch (e) { }
module.exports = perf_hooks;


text:
import multiprocessing
import numpy as np

from .model import Model
from ..grid import SphericalPolarGrid
from ..util.interpolate import interp1d_fast
from .analytical_yso_model import AnalyticalYSOModel

def find_last_iteration(file_handle):
    max_iteration = 0
    for group_name in file_handle:
        if "iteration" in group_name:
            iteration = int(group_name.split('_')[1])
            max_iteration = max(iteration, max_iteration)
    return max_iteration

def tau_to_radius(model, tau, wav):
    """
    Given a Model instance with a spherical polar coordinate grid, find the
    radius from which the optical depth to escape radially is a fixed value.

    This only works for spherical polar grids, but works for 1-, 2-, and
    3-d grids.

    Parameters
    ----------
    model : `~hyperion.model.Model` instance
    tau : float
        The optical depth for which to find the surface
    wav : float
        The wavelength at which the optical depth is defined

    Returns
    -------
    r : np.ndarray
        The radius or radii at which the optical depth to escape radially
        is ``tau`` at ``wav``. This is a scalar, a 1-d, or a 2-d array
        depending on the dimensionality of the grid.
    """

    if not isinstance(model, Model):
        raise TypeError("model should be a Model instance")

    if model.grid is None:
        raise Exception("Coordinate grid has not been defined")

    if not isinstance(model.grid, SphericalPolarGrid):
        raise TypeError("This method can only be called for spherical polar grids")

    # Initialize cumulative optical depth array
    tau_all = np.zeros(model.grid.shape)

    # Loop over envelopes and add cumulative column density
    for i, item in enumerate(model.grid['density']):

        # Find density
        rho = item.array

        # Find optical depth in all cells in radial direction
        dtau = model.grid.widths[0, :, :, :] * rho * model.dust[i].optical_properties.interp_chi_wav(wav)

        # Find cumulative sum starting from the ouside
        tau_all += np.cumsum(dtau[:, :, ::-1], axis=2)

    r = np.zeros(model.grid.shape[:2])
    for ip in range(model.grid.shape[0]):
        for it in range(model.grid.shape[1]):
            tau_col = np.hstack([0., tau_all[ip, it, :]])
            if tau < np.max(tau_col):
                r[ip, it] = interp1d_fast(tau_col, model.grid.r_wall[::-1], tau)
                # print(tau_col, r[ip, it])
            else:
                r[ip, it] = 0.

    return r

def hseq_profile(w, z, temperature, mstar, mu=2.279):
    """
    Compute the new (normalized) density profile
    corresponding to a given temperature profile

    Parameters
    ----------
    w : float
        The cylindrical radius at which to compute the profile (in cm)
    z : np.ndarray
        The z coordinates of the cells at radius w (in cm)
    temperature : np.ndarray
        The temperatures in the cells (in K)
    mstar : float
        The mass of the star (in g)
    """

    from hyperion.util.constants import G, m_h, k
    from ..util.integrate import integrate, integrate_subset

    # Compute the integrand
    integrand = z / temperature / (w ** 2 + z ** 2) ** 1.5

    # Compute the integral for all cells
    # TODO - inefficient to compute integral from scratch - optimize
    i = np.array([integrate_subset(z, integrand, 0., zmax) for zmax in z])
    i[z < 0] = -i[z < 0]

    # Compute the factor for the integrand
    factor = G * mstar * mu * m_h / k

    # Compute the profile
    density = np.exp(-i * factor) / temperature

    # Normalize the density profile
    density = density / integrate(z, density)

    return density

# The mean molecular weight of H2 + He is given by:
#
# mu = 4 * (X + 1) / (X + 2)
#
# where X is the mass fraction of Helium to Hydrogren. Assuming
#
# X = 0.32476319350473615
#
# gives:
#
# mu = 2.279

def run_with_vertical_hseq(prefix, model, n_iter=10, mpi=False,
                           n_processes=multiprocessing.cpu_count(),
                           overwrite=False):
    """
    Run a model with vertical hydrostatic equilibrium.

    .. note:: this is an experimental function that is currently in
              development. Please use with care!

    The hydrostatic equilibrium condition is only applied to the disk
    components. The following requirements must be met:

    - The model should be an AnalyticalYSOModel
    - The model should be defined on a cylindrical polar grid
    - The stellar mass should be set
    - The model should include at least one disk

    The dust properties for the model can be specified as dust or dust+gas
    densities as this does not have an impact on this calculation - however,
    the hydrostatic equilibrium is computed assuming an H2 + He mix of gas
    (i.e. mu=2.279). Note that this calculation also ignores the effects of
    self-gravity in the disk, which might be important for more massive disks.

    Parameters
    ----------
    prefix : str
        The prefix for the output
    model : `~hyperion.model.analytical_yso_model.AnalyticalYSOModel`
        The model to run
    n_iter : int, optional
        The number of iterations to run the model for
    mpi : bool, optional
        Whether to run the model in parallel
    n_processes : int, optional
        The number of processes to use if ``mpi`` is ``True``
    overwrite : bool, optional
        Whether to overwrite previous files
    """

    from ..grid import CylindricalPolarGrid
    from .model_output import ModelOutput
    from ..util.integrate import integrate

    if not isinstance(model, AnalyticalYSOModel):
        raise TypeError("Can only run hydrostatic equilibrium for AnalyticalYSOModel instances")

    if not isinstance(model.grid, CylindricalPolarGrid):
        raise TypeError("Can only run hydrostatic equilibrium for models with cylindrical polar grids")

    if model.star.mass is None:
        raise ValueError("Stellar mass needs to be defined for calculation of hydrostatic equilibrium")

    if len(model.disks) == 0:
        raise ValueError("Can only run hydrostatic equilibrium for models with disks")
    else:
        n_disks = len(model.disks)

    # Write out initial model
    model.write(prefix + '_00000.rtin', overwrite=overwrite, merge_if_possible=False)

    # Run the initial model
    mo = model.run(prefix + '_00000.rtout', overwrite=overwrite,
                   mpi=mpi, n_processes=n_processes)

    previous = prefix + '_00000.rtout'

    for iteration in range(1, n_iter + 1):

        # Read in output
        mo = ModelOutput(previous)

        # Extract the quantities
        g = mo.get_quantities()

        # Get wall positions
        rw, zw = g.w_wall, g.z_wall

        # Make a 2-d grid of wall positions
        R, Z = np.meshgrid(rw, zw)

        # Extract density and temperature
        density = g['density']
        temperature = g['temperature']

        # TODO: need to find a better way than just assuming the first n
        # density grids are disks

        for idisk in range(n_disks):

            # Vertically extrapolate temperatures
            for i in range(len(g.w)):
                for j in range(len(g.p)):
                    reset = temperature[idisk].array[j, :, i] < 1.
                    temperature[idisk].array[j, reset, i] = np.max(temperature[idisk].array[j, :, i])  # shouldn't be max, but will do for now

            # Compute new density
            for i in range(len(g.w)):
                for j in range(len(g.p)):
                    density[idisk].array[j, :, i] = hseq_profile(g.w[i], g.z, temperature[idisk].array[j, :, i], model.star.mass) * integrate(g.z, density[idisk].array[j, :, i])

        # Instantiate new model based on previous
        m = Model.read(previous)

        # Override the density
        m.grid['density'] = density

        # Write and run
        m.write('{0:s}_{1:05d}.rtin'.format(prefix, iteration), overwrite=overwrite)
        m.run('{0:s}_{1:05d}.rtout'.format(prefix, iteration),
              overwrite=overwrite, mpi=mpi, n_processes=n_processes)

        previous = '{0:s}_{1:05d}.rtout'.format(prefix, iteration)


text:
package com.yahala.android.emoji;

import android.content.res.Resources;

/**
 * Created by user on 8/1/2014.
 */
public class Emoji {

    public String name;
    public String unicode;
    public String category;
    public String moji;
    public String emoticon;
    public String assetPath;

    public Resources res;
}


text:
class CombatSystem : public GameSystemBase {
public:
    void registerHandlers() override;
    void handleAttack(EntityId attacker, EntityId defender);
    void updateLog(const EntityId& attacker, const EntityId& target,
                   int damage);
    void killEntity(EntityId id);
};


text:
<?php

//http://code.tutsplus.com/tutorials/how-to-create-custom-wordpress-writemeta-boxes--wp-20336

// CREATE

add_action( 'add_meta_boxes', 'product_options_meta_box_add' );

function product_options_meta_box_add()
{
    add_meta_box( 'product_options_meta_box', 'Product Options', 'product_options_meta_box_content', 'product', 'side', 'high' );
}

function product_options_meta_box_content()
{
    // $post is already set, and contains an object: the WordPress post
    global $post;
    $values = get_post_custom( $post->ID );
    $check = isset($values['product_full_screen_description_meta_box_check']) ? esc_attr($values['product_full_screen_description_meta_box_check'][0]) : 'off';
    ?>

        <input type="checkbox" id="product_full_screen_description_meta_box_check" name="product_full_screen_description_meta_box_check" <?php checked( $check, 'on' ); ?> />
        Fullscreen Description

    <?php

	// We'll use this nonce field later on when saving.
    wp_nonce_field( 'product_options_meta_box', 'product_options_meta_box_nonce' );
}

// SAVE

add_action( 'save_post', 'product_options_meta_box_save' );

function product_options_meta_box_save($post_id)
{
    // Bail if we're doing an auto save
    if( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) return;

    // if our nonce isn't there, or we can't verify it, bail
    if( !isset( $_POST['product_options_meta_box_nonce'] ) || !wp_verify_nonce( $_POST['product_options_meta_box_nonce'], 'product_options_meta_box' ) ) return;

    // if our current user can't edit this post, bail
    if ( !current_user_can( 'edit_post', $post_id ) ) return;

    $chk = isset($_POST['product_full_screen_description_meta_box_check']) ? 'on' : 'off';
    update_post_meta( $post_id, 'product_full_screen_description_meta_box_check', $chk );
}


text:
<script>
	$('#frmNewsletter').validate({
		rules: {
            email: {
                remote: {
                    url: "{% url 'newsletter_email_validate' %}",
                    type: 'get'
                }
            }
        },
        messages: {
            email: {
                remote: 'Subscriber with this email address already exists'
            }
        },
	    submitHandler: function(form){
	        $(form).ajaxSubmit({
	            success: function(data){
	                data = JSON.parse(data);
	                if(data.success){
	                	$(form).html(data.message);
	                } else{
	                    alert('Error subscribing to newsletter');
	                }
	            }
	        });
	    }
	});
</script>


text:
/**
 * \brief Timeseries operation traits
 */

#ifndef __TIMESERIES_OPER_TRAITS_HPP_
#define __TIMESERIES_OPER_TRAITS_HPP_

#include <jflib/timeseries/structures.hpp>
#include <jflib/timeseries/traits/matrix.hpp>
#include <boost/numeric/ublas/symmetric.hpp>

// Boost numeric bindings
//#include <jflib/linalg/lapack/eigen.hpp>
#include <boost/numeric/bindings/traits/type_traits.hpp>
#include <boost/numeric/bindings/traits/ublas_vector.hpp>
#include <boost/numeric/bindings/traits/ublas_matrix.hpp>
#include <boost/numeric/bindings/lapack/driver/gels.hpp>

namespace jflib { namespace timeseries {

namespace lapack = boost::numeric::bindings::lapack;

}}

namespace jflib { namespace timeseries { namespace traits {

template<class TS, unsigned D>
class oper_traits;

template<class TS>
struct oper_traits<TS,0u> {};

template<class T>
struct oper_traits_vector {
	typedef boost::numeric::ublas::vector<T>	type;
};
template<class T>
struct oper_traits_matrix {
	typedef boost::numeric::ublas::matrix<T>	type;
};
template<class T>
struct oper_traits_symmetric {
	typedef boost::numeric::ublas::symmetric_matrix<T>	type;
};
template<class T, unsigned D>
struct oper_traits_bounded_vector {
	typedef boost::numeric::ublas::bounded_array<T,D>		storage_type;
	typedef boost::numeric::ublas::vector<T,storage_type>	type;
	//typedef boost::numeric::ublas::bounded_vector<numtype,D>	type;
};

template<class Key, class T, class Tag, unsigned F>
class oper_traits<timeseries<Key,T,Tag,F,false>, 1u> {
public:
	typedef typename ts<Key,T,Tag>::type	tstype;
	typedef typename tstype::numtype		numtype;
	typedef numtype							type;

	static void init(const tstype& ts, type& v) {v = 0;}
};

template<class Key, class T, class Tag, unsigned F, unsigned D>
class oper_traits<timeseries<Key,T,Tag,F,false>, D> {
public:
	typedef typename ts<Key,T,Tag>::type							tstype;
	typedef typename tstype::numtype								numtype;
	typedef typename oper_traits_bounded_vector<numtype,D>::type	type;

	static void init(const tstype& ts, type& v) {
		v.resize(D,false);
		std::fill(v.begin(),v.end(),0);
	}
};

template<class TS>
class oper_traits<TS,1u> {
public:
	typedef TS												tstype;
	typedef typename tstype::numtype						numtype;
	typedef typename oper_traits_vector<numtype>::type		type;

	static void init(const tstype& ts, type& v) {
		v.resize(ts.series(),false);
		std::fill(v.begin(),v.end(),0);
	}
};

template<class TS, unsigned D>
class oper_traits {
public:
	typedef TS														tstype;
	typedef typename tstype::numtype								numtype;
	typedef typename oper_traits_vector<numtype>::type				vectype;
	typedef typename oper_traits_bounded_vector<vectype,D>::type	type;

	static void init(const tstype& ts, type& v) {
		vectype vec(ts.series(), 0);
		v.resize(D,false);
		std::fill(v.begin(),v.end(),vec);
	}
};

}}}

#endif	//	__TIMESERIES_OPER_TRAITS_HPP_


text:
namespace _09_16.TasksStudentGroups
{
    using System;
    using System.Collections.Generic;

    public class Student
    {
        private string firstName;
        private string lastName;
        private int fn;
        private string tel;
        private List<int> marks;
        private string email;
        private int groupNumber;

        public Student(string firstName, string lastName, int fn, string tel, string email, List<int> marks, int groupNumber)
        {
            this.FirstName = firstName;
            this.LastName = lastName;
            this.FN = fn;
            this.Tel = tel;
            this.Email = email;
            this.Marks = marks;
            this.GroupNumber = groupNumber;

        }

        public string FirstName
        {
            get { return this.firstName; }
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw new ArgumentNullException("First name should exist");
                }
                this.firstName = value;
            }
        }

        public string LastName
        {
            get { return this.lastName; }
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw new ArgumentNullException("First name should exist");
                }
                this.lastName = value;
            }
        }

        public int FN
        {
            get
            { return this.fn; }
            set
            {
                if (value < 100000 || value > 999999)
                {
                    throw new ArgumentOutOfRangeException("Student number should be between 100000 and 999999");
                }
                this.fn = value;
            }
        }

        public string Tel
        {
            get
            { return this.tel; }
            set
            {
                if (value.Length < 3)
                {
                    throw new ArgumentNullException("Telephone number cannot be shorter than 3 numbers");
                }
                this.tel = value;
            }
        }

        public string Email
        {
            get
            { return this.email; }
            set
            {
                if (value.IndexOf("@") == -1 || value.IndexOf(".") == -1)
                {
                    throw new ArgumentNullException("This is not a valid e-mail");
                }
                this.email = value;
            }
        }

        public int GroupNumber
        {
            get
            { return this.groupNumber; }
            set
            {
                if (value < 1 || value > 10)
                {
                    throw new ArgumentOutOfRangeException("Group number should be between 1 and 9");
                }
                this.groupNumber = value;
            }
        }

        public List<int> Marks
        {
            get
            { return this.marks; }
            set
            {
                foreach (var mark in value)
                {
                    if (mark < 2 || mark > 6)
                    {
                        throw new ArgumentOutOfRangeException("Marks should be between 2 and 6!");
                    }
                }
                this.marks = value;
            }
        }

        public string ReturnMarks()
        {
            string marks = string.Empty;

            foreach (var item in this.Marks)
            {
                marks += item + ", ";
            }

            if (marks != string.Empty)
            {
                marks = marks.Substring(0, marks.Length - 2);
            }
            return marks;
        }

        public override string ToString()
        {
            return this.firstName + " " + this.lastName;
        }
    }
}


text:
@interface MyTweetLikeListCell : UITableViewCell

@property (nonatomic, strong) UIImageView *portrait;
@property (nonatomic, strong) UILabel *likeUserNameLabel;
@property (nonatomic, strong) UILabel *textlLikeLabel;
@property (nonatomic, strong) UILabel *timeLabel;

@property (nonatomic, strong) UILabel *authorTweetLabel;

- (void)setContentWithMyTweetLikeList:(OSCMyTweetLikeList *)myLikeTweet;

@end


text:
package Dec2020Leetcode;

import java.util.ArrayList;
import java.util.List;

public class _0077Combinations {

	public static void main(String[] args) {
		System.out.println(combine(4, 2));
		System.out.println(combine(1, 1));
	}

	public static List<List<Integer>> combine(int n, int k) {
		List<List<Integer>> output = new ArrayList<List<Integer>>();
		dfs(1, n, k, new ArrayList<Integer>(), output);
		return output;
	}

	public static void dfs(int start, int n, int k, List<Integer> list, List<List<Integer>> output) {
		if (list.size() > k)
			return;

		if (list.size() == k) {
			output.add(new ArrayList<Integer>(list));
			return;
		}

		for (int i = start; i <= n; i++) {
			list.add(i);
			dfs(i + 1, n, k, list, output);
			list.remove(list.size() - 1);
		}
	}
}


text:
package com.inexinnovation.controller.dao;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.csv.CsvMapper;
import com.fasterxml.jackson.dataformat.csv.CsvSchema;
import com.inexinnovation.controller.model.Customer;
import com.inexinnovation.controller.utility.RandomStringGenerator;

public class CustomerDao {

	private static ArrayList<Customer> CUSTOMER_IN_MEMORY_DAO = new ArrayList<Customer>();

	private static Logger LOGGER = LoggerFactory
			.getLogger(CustomerDao.class);

	private static String DATA_DIR = System.getenv("DATA_DIR");

	public ArrayList<Customer> getCustomers() {
		return CUSTOMER_IN_MEMORY_DAO;
	}  // ArrayList<Customer> getCustomers

	public Customer getCustomerById(String customerId)
	{
		int customerSize = CUSTOMER_IN_MEMORY_DAO.size();

		Customer returnCustomer = null;

		int targetIndex = -1;

		for (int index = 0; index < customerSize; index++)
		{
			LOGGER.debug(CUSTOMER_IN_MEMORY_DAO.get(index).getCustomerId() + " COMPARE AGAINST " + customerId);
			if(CUSTOMER_IN_MEMORY_DAO.get(index).getCustomerId().equalsIgnoreCase(customerId))
			{
				targetIndex = index;
				index = customerSize;
			}  // if
		}  // for

		if(targetIndex != -1)
		{
			returnCustomer = CUSTOMER_IN_MEMORY_DAO.get(targetIndex);
		}  // if

		return returnCustomer;
	}  // Customer getCustomerById

	public String getCustomerInCSV() throws IOException
	{
		CsvMapper mapper = new CsvMapper();
	    CsvSchema schema = mapper.schemaFor(Customer.class).withHeader();
	    return mapper.writer(schema).writeValueAsString(CUSTOMER_IN_MEMORY_DAO);
	}  // String getCustomerInCSV

	public synchronized void deleteCustomer(String customerId) throws JsonGenerationException, JsonMappingException, IOException
	{
		int customerSize = CUSTOMER_IN_MEMORY_DAO.size();

		int targetIndex = -1;

		for (int index = 0; index < customerSize; index++)
		{
			if(CUSTOMER_IN_MEMORY_DAO.get(index).getCustomerId().equalsIgnoreCase(customerId))
			{
				targetIndex = index;
				index = customerSize;
			}  // if
		}  // for

		if(targetIndex != -1)
		{
			CUSTOMER_IN_MEMORY_DAO.remove(targetIndex);

			ObjectMapper lMapper = new ObjectMapper();
			lMapper.writeValue(new File(DATA_DIR + "/data.json"),
					CUSTOMER_IN_MEMORY_DAO);
		}  // if

	}  // void deleteCustomer

	public synchronized Customer updateCustomer(String customerId, Customer customer) throws JsonGenerationException, JsonMappingException, IOException
	{
		int customerSize = CUSTOMER_IN_MEMORY_DAO.size();
		Customer returnCustomer = null;
		int targetIndex = -1;

		for (int index = 0; index < customerSize; index++)
		{
			if(CUSTOMER_IN_MEMORY_DAO.get(index).getCustomerId().equalsIgnoreCase(customerId))
			{
				targetIndex = index;
				index = customerSize;
			}  // if
		}  // for

		if(targetIndex != -1)
		{
			customer.setCustomerId(customerId);

			CUSTOMER_IN_MEMORY_DAO.get(targetIndex).setCustomerFirstName(customer.getCustomerFirstName());
			CUSTOMER_IN_MEMORY_DAO.get(targetIndex).setCustomerLastName(customer.getCustomerLastName());
			CUSTOMER_IN_MEMORY_DAO.get(targetIndex).setCustomerEmail(customer.getCustomerLastName());
			CUSTOMER_IN_MEMORY_DAO.get(targetIndex).setCustomerPhone(customer.getCustomerPhone());

			CUSTOMER_IN_MEMORY_DAO.get(targetIndex).setCustomerCountry(customer.getCustomerLastName());

			CUSTOMER_IN_MEMORY_DAO.get(targetIndex).setCustomerDataUsageAgreement(customer.getCustomerDataUsageAgreement());

			CUSTOMER_IN_MEMORY_DAO.get(targetIndex).setCustomerAdditionalComment(customer.getCustomerAdditionalComment());

			returnCustomer = CUSTOMER_IN_MEMORY_DAO.get(targetIndex);
		}  // if

		ObjectMapper lMapper = new ObjectMapper();
		lMapper.writeValue(new File(DATA_DIR + "/data.json"),
				CUSTOMER_IN_MEMORY_DAO);

		return returnCustomer;
	}  // Customer deleteCustomer

	public synchronized Customer saveCustomer(Customer customer)
			throws JsonGenerationException, JsonMappingException, IOException {

		customer.setCustomerId(RandomStringGenerator.generator(30));

		CUSTOMER_IN_MEMORY_DAO.add(customer);

		ObjectMapper lMapper = new ObjectMapper();
		lMapper.writeValue(new File(DATA_DIR + "/data.json"),
				CUSTOMER_IN_MEMORY_DAO);

		return customer;
	}  // Customer saveCustomer

	public synchronized void readCustomers() throws JsonGenerationException,
			JsonMappingException, IOException {
		File lFile = new File(DATA_DIR + "/data.json");

		LOGGER.info("Loading existing configuration from: " + lFile.getAbsolutePath());

		// Only perform memory reading if file exists
		if (lFile.canRead()) {

			ArrayList<Customer> lTempCustomers = new ArrayList<Customer>();

			ObjectMapper lMapper = new ObjectMapper();
			lTempCustomers =lMapper.readValue(
					lFile, lMapper.getTypeFactory().constructCollectionType(ArrayList.class, Customer.class));

			CUSTOMER_IN_MEMORY_DAO.clear();

			for (Customer tempCustomer : lTempCustomers) {
				CUSTOMER_IN_MEMORY_DAO.add(tempCustomer);
			} // for
		} // if
	}  // void readCustomers()
}  // class CustomerDao