text:
using System;

namespace System.Linq.Expressions
{
    /// <summary>
    ///    Strongly-typed and parameterized exception factory.
    /// </summary>
    internal static partial class Error
    {
        /// <summary>
        /// ArgumentException with message like "reducible nodes must override Expression.Reduce()"
        /// </summary>
        internal static Exception ReducibleMustOverrideReduce()
        {
            return new ArgumentException(Strings.ReducibleMustOverrideReduce);
        }
        /// <summary>
        /// ArgumentException with message like "node cannot reduce to itself or null"
        /// </summary>
        internal static Exception MustReduceToDifferent()
        {
            return new ArgumentException(Strings.MustReduceToDifferent);
        }
        /// <summary>
        /// ArgumentException with message like "cannot assign from the reduced node type to the original node type"
        /// </summary>
        internal static Exception ReducedNotCompatible()
        {
            return new ArgumentException(Strings.ReducedNotCompatible);
        }
        /// <summary>
        /// ArgumentException with message like "Setter must have parameters."
        /// </summary>
        internal static Exception SetterHasNoParams(string paramName)
        {
            return new ArgumentException(Strings.SetterHasNoParams, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Property cannot have a managed pointer type."
        /// </summary>
        internal static Exception PropertyCannotHaveRefType(string paramName)
        {
            return new ArgumentException(Strings.PropertyCannotHaveRefType, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Indexing parameters of getter and setter must match."
        /// </summary>
        internal static Exception IndexesOfSetGetMustMatch(string paramName)
        {
            return new ArgumentException(Strings.IndexesOfSetGetMustMatch, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Accessor method should not have VarArgs."
        /// </summary>
        internal static Exception AccessorsCannotHaveVarArgs(string paramName)
        {
            return new ArgumentException(Strings.AccessorsCannotHaveVarArgs, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Accessor indexes cannot be passed ByRef."
        /// </summary>
        internal static Exception AccessorsCannotHaveByRefArgs(string paramName)
        {
            return new ArgumentException(Strings.AccessorsCannotHaveByRefArgs, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Bounds count cannot be less than 1"
        /// </summary>
        internal static Exception BoundsCannotBeLessThanOne(string paramName)
        {
            return new ArgumentException(Strings.BoundsCannotBeLessThanOne, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Type must not be ByRef"
        /// </summary>
        internal static Exception TypeMustNotBeByRef(string paramName)
        {
            return new ArgumentException(Strings.TypeMustNotBeByRef, paramName);
        }

        /// <summary>
        /// ArgumentException with message like "Type must not be a pointer type"
        /// </summary>
        internal static Exception TypeMustNotBePointer(string paramName)
        {
            return new ArgumentException(Strings.TypeMustNotBePointer, paramName);
        }

        /// <summary>
        /// ArgumentException with message like "Type doesn't have constructor with a given signature"
        /// </summary>
        internal static Exception TypeDoesNotHaveConstructorForTheSignature()
        {
            return new ArgumentException(Strings.TypeDoesNotHaveConstructorForTheSignature);
        }
        /// <summary>
        /// ArgumentException with message like "Setter should have void type."
        /// </summary>
        internal static Exception SetterMustBeVoid(string paramName)
        {
            return new ArgumentException(Strings.SetterMustBeVoid, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Property type must match the value type of setter"
        /// </summary>
        internal static Exception PropertyTypeMustMatchSetter(string paramName)
        {
            return new ArgumentException(Strings.PropertyTypeMustMatchSetter);
        }
        /// <summary>
        /// ArgumentException with message like "Both accessors must be static."
        /// </summary>
        internal static Exception BothAccessorsMustBeStatic(string paramName)
        {
            return new ArgumentException(Strings.BothAccessorsMustBeStatic, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Static method requires null instance, non-static method requires non-null instance."
        /// </summary>
        internal static Exception OnlyStaticMethodsHaveNullInstance()
        {
            return new ArgumentException(Strings.OnlyStaticMethodsHaveNullInstance);
        }
        /// <summary>
        /// ArgumentException with message like "Property cannot have a void type."
        /// </summary>
        internal static Exception PropertyTypeCannotBeVoid(string paramName)
        {
            return new ArgumentException(Strings.PropertyTypeCannotBeVoid, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Can only unbox from an object or interface type to a value type."
        /// </summary>
        internal static Exception InvalidUnboxType(string paramName)
        {
            return new ArgumentException(Strings.InvalidUnboxType, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must not have a value type."
        /// </summary>
        internal static Exception ArgumentMustNotHaveValueType(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustNotHaveValueType, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "must be reducible node"
        /// </summary>
        internal static Exception MustBeReducible()
        {
            return new ArgumentException(Strings.MustBeReducible);
        }
        /// <summary>
        /// ArgumentException with message like "Default body must be supplied if case bodies are not System.Void."
        /// </summary>
        internal static Exception DefaultBodyMustBeSupplied(string paramName)
        {
            return new ArgumentException(Strings.DefaultBodyMustBeSupplied, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Label type must be System.Void if an expression is not supplied"
        /// </summary>
        internal static Exception LabelMustBeVoidOrHaveExpression(string paramName)
        {
            return new ArgumentException(Strings.LabelMustBeVoidOrHaveExpression, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Type must be System.Void for this label argument"
        /// </summary>
        internal static Exception LabelTypeMustBeVoid(string paramName)
        {
            return new ArgumentException(Strings.LabelTypeMustBeVoid, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Quoted expression must be a lambda"
        /// </summary>
        internal static Exception QuotedExpressionMustBeLambda(string paramName)
        {
            return new ArgumentException(Strings.QuotedExpressionMustBeLambda, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Variable '{0}' uses unsupported type '{1}'. Reference types are not supported for variables."
        /// </summary>
        internal static Exception VariableMustNotBeByRef(object p0, object p1, string paramName)
        {
            return new ArgumentException(Strings.VariableMustNotBeByRef(p0, p1), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Found duplicate parameter '{0}'. Each ParameterExpression in the list must be a unique object."
        /// </summary>
        internal static Exception DuplicateVariable(object p0, string paramName)
        {
            return new ArgumentException(Strings.DuplicateVariable(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Start and End must be well ordered"
        /// </summary>
        internal static Exception StartEndMustBeOrdered()
        {
            return new ArgumentException(Strings.StartEndMustBeOrdered);
        }
        /// <summary>
        /// ArgumentException with message like "fault cannot be used with catch or finally clauses"
        /// </summary>
        internal static Exception FaultCannotHaveCatchOrFinally(string paramName)
        {
            return new ArgumentException(Strings.FaultCannotHaveCatchOrFinally, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "try must have at least one catch, finally, or fault clause"
        /// </summary>
        internal static Exception TryMustHaveCatchFinallyOrFault()
        {
            return new ArgumentException(Strings.TryMustHaveCatchFinallyOrFault);
        }
        /// <summary>
        /// ArgumentException with message like "Body of catch must have the same type as body of try."
        /// </summary>
        internal static Exception BodyOfCatchMustHaveSameTypeAsBodyOfTry()
        {
            return new ArgumentException(Strings.BodyOfCatchMustHaveSameTypeAsBodyOfTry);
        }
        /// <summary>
        /// InvalidOperationException with message like "Extension node must override the property {0}."
        /// </summary>
        internal static Exception ExtensionNodeMustOverrideProperty(object p0)
        {
            return new InvalidOperationException(Strings.ExtensionNodeMustOverrideProperty(p0));
        }
        /// <summary>
        /// ArgumentException with message like "User-defined operator method '{0}' must be static."
        /// </summary>
        internal static Exception UserDefinedOperatorMustBeStatic(object p0, string paramName)
        {
            return new ArgumentException(Strings.UserDefinedOperatorMustBeStatic(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "User-defined operator method '{0}' must not be void."
        /// </summary>
        internal static Exception UserDefinedOperatorMustNotBeVoid(object p0, string paramName)
        {
            return new ArgumentException(Strings.UserDefinedOperatorMustNotBeVoid(p0), paramName);
        }
        /// <summary>
        /// InvalidOperationException with message like "No coercion operator is defined between types '{0}' and '{1}'."
        /// </summary>
        internal static Exception CoercionOperatorNotDefined(object p0, object p1)
        {
            return new InvalidOperationException(Strings.CoercionOperatorNotDefined(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "The unary operator {0} is not defined for the type '{1}'."
        /// </summary>
        internal static Exception UnaryOperatorNotDefined(object p0, object p1)
        {
            return new InvalidOperationException(Strings.UnaryOperatorNotDefined(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "The binary operator {0} is not defined for the types '{1}' and '{2}'."
        /// </summary>
        internal static Exception BinaryOperatorNotDefined(object p0, object p1, object p2)
        {
            return new InvalidOperationException(Strings.BinaryOperatorNotDefined(p0, p1, p2));
        }
        /// <summary>
        /// InvalidOperationException with message like "Reference equality is not defined for the types '{0}' and '{1}'."
        /// </summary>
        internal static Exception ReferenceEqualityNotDefined(object p0, object p1)
        {
            return new InvalidOperationException(Strings.ReferenceEqualityNotDefined(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "The operands for operator '{0}' do not match the parameters of method '{1}'."
        /// </summary>
        internal static Exception OperandTypesDoNotMatchParameters(object p0, object p1)
        {
            return new InvalidOperationException(Strings.OperandTypesDoNotMatchParameters(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "The return type of overload method for operator '{0}' does not match the parameter type of conversion method '{1}'."
        /// </summary>
        internal static Exception OverloadOperatorTypeDoesNotMatchConversionType(object p0, object p1)
        {
            return new InvalidOperationException(Strings.OverloadOperatorTypeDoesNotMatchConversionType(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "Conversion is not supported for arithmetic types without operator overloading."
        /// </summary>
        internal static Exception ConversionIsNotSupportedForArithmeticTypes()
        {
            return new InvalidOperationException(Strings.ConversionIsNotSupportedForArithmeticTypes);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must be array"
        /// </summary>
        internal static Exception ArgumentMustBeArray(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeArray, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must be boolean"
        /// </summary>
        internal static Exception ArgumentMustBeBoolean(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeBoolean, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "The user-defined equality method '{0}' must return a boolean value."
        /// </summary>
        internal static Exception EqualityMustReturnBoolean(object p0, string paramName)
        {
            return new ArgumentException(Strings.EqualityMustReturnBoolean(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must be either a FieldInfo or PropertyInfo"
        /// </summary>
        internal static Exception ArgumentMustBeFieldInfoOrPropertyInfo(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeFieldInfoOrPropertyInfo, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must be either a FieldInfo, PropertyInfo or MethodInfo"
        /// </summary>
        internal static Exception ArgumentMustBeFieldInfoOrPropertyInfoOrMethod(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeFieldInfoOrPropertyInfoOrMethod, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must be an instance member"
        /// </summary>
        internal static Exception ArgumentMustBeInstanceMember(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeInstanceMember, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must be of an integer type"
        /// </summary>
        internal static Exception ArgumentMustBeInteger(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeInteger, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument for array index must be of type Int32"
        /// </summary>
        internal static Exception ArgumentMustBeArrayIndexType(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeArrayIndexType, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument must be single dimensional array type"
        /// </summary>
        internal static Exception ArgumentMustBeSingleDimensionalArrayType(string paramName)
        {
            return new ArgumentException(Strings.ArgumentMustBeSingleDimensionalArrayType, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument types do not match"
        /// </summary>
        internal static Exception ArgumentTypesMustMatch()
        {
            return new ArgumentException(Strings.ArgumentTypesMustMatch);
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot auto initialize elements of value type through property '{0}', use assignment instead"
        /// </summary>
        internal static Exception CannotAutoInitializeValueTypeElementThroughProperty(object p0)
        {
            return new InvalidOperationException(Strings.CannotAutoInitializeValueTypeElementThroughProperty(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot auto initialize members of value type through property '{0}', use assignment instead"
        /// </summary>
        internal static Exception CannotAutoInitializeValueTypeMemberThroughProperty(object p0)
        {
            return new InvalidOperationException(Strings.CannotAutoInitializeValueTypeMemberThroughProperty(p0));
        }
        /// <summary>
        /// ArgumentException with message like "The type used in TypeAs Expression must be of reference or nullable type, {0} is neither"
        /// </summary>
        internal static Exception IncorrectTypeForTypeAs(object p0, string paramName)
        {
            return new ArgumentException(Strings.IncorrectTypeForTypeAs(p0), paramName);
        }
        /// <summary>
        /// InvalidOperationException with message like "Coalesce used with type that cannot be null"
        /// </summary>
        internal static Exception CoalesceUsedOnNonNullType()
        {
            return new InvalidOperationException(Strings.CoalesceUsedOnNonNullType);
        }
        /// <summary>
        /// InvalidOperationException with message like "An expression of type '{0}' cannot be used to initialize an array of type '{1}'"
        /// </summary>
        internal static Exception ExpressionTypeCannotInitializeArrayType(object p0, object p1)
        {
            return new InvalidOperationException(Strings.ExpressionTypeCannotInitializeArrayType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Expression of type '{0}' cannot be used for constructor parameter of type '{1}'"
        /// </summary>
        internal static Exception ExpressionTypeDoesNotMatchConstructorParameter(object p0, object p1)
        {
            return Dynamic.Utils.Error.ExpressionTypeDoesNotMatchConstructorParameter(p0, p1);
        }
        /// <summary>
        /// ArgumentException with message like " Argument type '{0}' does not match the corresponding member type '{1}'"
        /// </summary>
        internal static Exception ArgumentTypeDoesNotMatchMember(object p0, object p1)
        {
            return new ArgumentException(Strings.ArgumentTypeDoesNotMatchMember(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like " The member '{0}' is not declared on type '{1}' being created"
        /// </summary>
        internal static Exception ArgumentMemberNotDeclOnType(object p0, object p1)
        {
            return new ArgumentException(Strings.ArgumentMemberNotDeclOnType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Expression of type '{0}' cannot be used for parameter of type '{1}' of method '{2}'"
        /// </summary>
        internal static Exception ExpressionTypeDoesNotMatchMethodParameter(object p0, object p1, object p2)
        {
            return Dynamic.Utils.Error.ExpressionTypeDoesNotMatchMethodParameter(p0, p1, p2);
        }
        /// <summary>
        /// ArgumentException with message like "Expression of type '{0}' cannot be used for return type '{1}'"
        /// </summary>
        internal static Exception ExpressionTypeDoesNotMatchReturn(object p0, object p1)
        {
            return new ArgumentException(Strings.ExpressionTypeDoesNotMatchReturn(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Expression of type '{0}' cannot be used for assignment to type '{1}'"
        /// </summary>
        internal static Exception ExpressionTypeDoesNotMatchAssignment(object p0, object p1)
        {
            return new ArgumentException(Strings.ExpressionTypeDoesNotMatchAssignment(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Expression of type '{0}' cannot be used for label of type '{1}'"
        /// </summary>
        internal static Exception ExpressionTypeDoesNotMatchLabel(object p0, object p1)
        {
            return new ArgumentException(Strings.ExpressionTypeDoesNotMatchLabel(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Expression of type '{0}' cannot be invoked"
        /// </summary>
        internal static Exception ExpressionTypeNotInvocable(object p0, string paramName)
        {
            return new ArgumentException(Strings.ExpressionTypeNotInvocable(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Field '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static Exception FieldNotDefinedForType(object p0, object p1)
        {
            return new ArgumentException(Strings.FieldNotDefinedForType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Instance field '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static Exception InstanceFieldNotDefinedForType(object p0, object p1)
        {
            return new ArgumentException(Strings.InstanceFieldNotDefinedForType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Field '{0}.{1}' is not defined for type '{2}'"
        /// </summary>
        internal static Exception FieldInfoNotDefinedForType(object p0, object p1, object p2)
        {
            return new ArgumentException(Strings.FieldInfoNotDefinedForType(p0, p1, p2));
        }
        /// <summary>
        /// ArgumentException with message like "Incorrect number of indexes"
        /// </summary>
        internal static Exception IncorrectNumberOfIndexes()
        {
            return new ArgumentException(Strings.IncorrectNumberOfIndexes);
        }
        /// <summary>
        /// ArgumentException with message like "Incorrect number of parameters supplied for lambda declaration"
        /// </summary>
        internal static Exception IncorrectNumberOfLambdaDeclarationParameters()
        {
            return new ArgumentException(Strings.IncorrectNumberOfLambdaDeclarationParameters);
        }
        /// <summary>
        /// ArgumentException with message like "Incorrect number of arguments supplied for call to method '{0}'"
        /// </summary>
        internal static Exception IncorrectNumberOfMethodCallArguments(object p0)
        {
            return Dynamic.Utils.Error.IncorrectNumberOfMethodCallArguments(p0);
        }
        /// <summary>
        /// ArgumentException with message like "Incorrect number of arguments for constructor"
        /// </summary>
        internal static Exception IncorrectNumberOfConstructorArguments()
        {
            return Dynamic.Utils.Error.IncorrectNumberOfConstructorArguments();
        }
        /// <summary>
        /// ArgumentException with message like " Incorrect number of members for constructor"
        /// </summary>
        internal static Exception IncorrectNumberOfMembersForGivenConstructor()
        {
            return new ArgumentException(Strings.IncorrectNumberOfMembersForGivenConstructor);
        }
        /// <summary>
        /// ArgumentException with message like "Incorrect number of arguments for the given members "
        /// </summary>
        internal static Exception IncorrectNumberOfArgumentsForMembers()
        {
            return new ArgumentException(Strings.IncorrectNumberOfArgumentsForMembers);
        }
        /// <summary>
        /// ArgumentException with message like "Lambda type parameter must be derived from System.MulticastDelegate"
        /// </summary>
        internal static Exception LambdaTypeMustBeDerivedFromSystemDelegate()
        {
            return new ArgumentException(Strings.LambdaTypeMustBeDerivedFromSystemDelegate);
        }
        /// <summary>
        /// ArgumentException with message like "Member '{0}' not field or property"
        /// </summary>
        internal static Exception MemberNotFieldOrProperty(object p0, string paramName)
        {
            return new ArgumentException(Strings.MemberNotFieldOrProperty(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Method {0} contains generic parameters"
        /// </summary>
        internal static Exception MethodContainsGenericParameters(object p0, string paramName)
        {
            return new ArgumentException(Strings.MethodContainsGenericParameters(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Method {0} is a generic method definition"
        /// </summary>
        internal static Exception MethodIsGeneric(object p0, string paramName)
        {
            return new ArgumentException(Strings.MethodIsGeneric(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "The method '{0}.{1}' is not a property accessor"
        /// </summary>
        internal static Exception MethodNotPropertyAccessor(object p0, object p1, string paramName)
        {
            return new ArgumentException(Strings.MethodNotPropertyAccessor(p0, p1), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "The property '{0}' has no 'get' accessor"
        /// </summary>
        internal static Exception PropertyDoesNotHaveGetter(object p0, string paramName)
        {
            return new ArgumentException(Strings.PropertyDoesNotHaveGetter(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "The property '{0}' has no 'set' accessor"
        /// </summary>
        internal static Exception PropertyDoesNotHaveSetter(object p0, string paramName)
        {
            return new ArgumentException(Strings.PropertyDoesNotHaveSetter(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "The property '{0}' has no 'get' or 'set' accessors"
        /// </summary>
        internal static Exception PropertyDoesNotHaveAccessor(object p0, string paramName)
        {
            return new ArgumentException(Strings.PropertyDoesNotHaveAccessor(p0), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "'{0}' is not a member of type '{1}'"
        /// </summary>
        internal static Exception NotAMemberOfType(object p0, object p1)
        {
            return new ArgumentException(Strings.NotAMemberOfType(p0, p1));
        }
        /// <summary>
        /// PlatformNotSupportedException with message like "The instruction '{0}' is not supported for type '{1}'"
        /// </summary>
        internal static Exception ExpressionNotSupportedForType(object p0, object p1)
        {
            return new PlatformNotSupportedException(Strings.ExpressionNotSupportedForType(p0, p1));
        }
        /// <summary>
        /// PlatformNotSupportedException with message like "The instruction '{0}' is not supported for nullable type '{1}'"
        /// </summary>
        internal static Exception ExpressionNotSupportedForNullableType(object p0, object p1)
        {
            return new PlatformNotSupportedException(Strings.ExpressionNotSupportedForNullableType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "ParameterExpression of type '{0}' cannot be used for delegate parameter of type '{1}'"
        /// </summary>
        internal static Exception ParameterExpressionNotValidAsDelegate(object p0, object p1)
        {
            return new ArgumentException(Strings.ParameterExpressionNotValidAsDelegate(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Property '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static Exception PropertyNotDefinedForType(object p0, object p1)
        {
            return new ArgumentException(Strings.PropertyNotDefinedForType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Instance property '{0}' is not defined for type '{1}'"
        /// </summary>
        internal static Exception InstancePropertyNotDefinedForType(object p0, object p1)
        {
            return new ArgumentException(Strings.InstancePropertyNotDefinedForType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Instance property '{0}' that takes no argument is not defined for type '{1}'"
        /// </summary>
        internal static Exception InstancePropertyWithoutParameterNotDefinedForType(object p0, object p1)
        {
            return new ArgumentException(Strings.InstancePropertyWithoutParameterNotDefinedForType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Instance property '{0}{1}' is not defined for type '{2}'"
        /// </summary>
        internal static Exception InstancePropertyWithSpecifiedParametersNotDefinedForType(object p0, object p1, object p2)
        {
            return new ArgumentException(Strings.InstancePropertyWithSpecifiedParametersNotDefinedForType(p0, p1, p2));
        }
        /// <summary>
        /// ArgumentException with message like "Method '{0}' declared on type '{1}' cannot be called with instance of type '{2}'"
        /// </summary>
        internal static Exception InstanceAndMethodTypeMismatch(object p0, object p1, object p2)
        {
            return new ArgumentException(Strings.InstanceAndMethodTypeMismatch(p0, p1, p2));
        }

        /// <summary>
        /// ArgumentException with message like "Type '{0}' does not have a default constructor"
        /// </summary>
        internal static Exception TypeMissingDefaultConstructor(object p0, string paramName)
        {
            return new ArgumentException(Strings.TypeMissingDefaultConstructor(p0), paramName);
        }

        /// <summary>
        /// ArgumentException with message like "Element initializer method must be named 'Add'"
        /// </summary>
        internal static Exception ElementInitializerMethodNotAdd(string paramName)
        {
            return new ArgumentException(Strings.ElementInitializerMethodNotAdd, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Parameter '{0}' of element initializer method '{1}' must not be a pass by reference parameter"
        /// </summary>
        internal static Exception ElementInitializerMethodNoRefOutParam(object p0, object p1, string paramName)
        {
            return new ArgumentException(Strings.ElementInitializerMethodNoRefOutParam(p0, p1), paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Element initializer method must have at least 1 parameter"
        /// </summary>
        internal static Exception ElementInitializerMethodWithZeroArgs(string paramName)
        {
            return new ArgumentException(Strings.ElementInitializerMethodWithZeroArgs, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Element initializer method must be an instance method"
        /// </summary>
        internal static Exception ElementInitializerMethodStatic(string paramName)
        {
            return new ArgumentException(Strings.ElementInitializerMethodStatic, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Type '{0}' is not IEnumerable"
        /// </summary>
        internal static Exception TypeNotIEnumerable(object p0, string paramName)
        {
            return new ArgumentException(Strings.TypeNotIEnumerable(p0), paramName);
        }
        /// <summary>
        /// InvalidOperationException with message like "Unexpected coalesce operator."
        /// </summary>
        internal static Exception UnexpectedCoalesceOperator()
        {
            return new InvalidOperationException(Strings.UnexpectedCoalesceOperator);
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot cast from type '{0}' to type '{1}"
        /// </summary>
        internal static Exception InvalidCast(object p0, object p1)
        {
            return new InvalidOperationException(Strings.InvalidCast(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Unhandled binary: {0}"
        /// </summary>
        internal static Exception UnhandledBinary(object p0)
        {
            return new ArgumentException(Strings.UnhandledBinary(p0));
        }
        /// <summary>
        /// ArgumentException with message like "Unhandled binding "
        /// </summary>
        internal static Exception UnhandledBinding()
        {
            return new ArgumentException(Strings.UnhandledBinding);
        }
        /// <summary>
        /// ArgumentException with message like "Unhandled Binding Type: {0}"
        /// </summary>
        internal static Exception UnhandledBindingType(object p0)
        {
            return new ArgumentException(Strings.UnhandledBindingType(p0));
        }
        /// <summary>
        /// ArgumentException with message like "Unhandled convert: {0}"
        /// </summary>
        internal static Exception UnhandledConvert(object p0)
        {
            return new ArgumentException(Strings.UnhandledConvert(p0));
        }
        /// <summary>
        /// ArgumentException with message like "Unhandled Expression Type: {0}"
        /// </summary>
        internal static Exception UnhandledExpressionType(object p0)
        {
            return new ArgumentException(Strings.UnhandledExpressionType(p0));
        }
        /// <summary>
        /// ArgumentException with message like "Unhandled unary: {0}"
        /// </summary>
        internal static Exception UnhandledUnary(object p0)
        {
            return new ArgumentException(Strings.UnhandledUnary(p0));
        }
        /// <summary>
        /// ArgumentException with message like "Unknown binding type"
        /// </summary>
        internal static Exception UnknownBindingType()
        {
            return new ArgumentException(Strings.UnknownBindingType);
        }
        /// <summary>
        /// ArgumentException with message like "The user-defined operator method '{1}' for operator '{0}' must have identical parameter and return types."
        /// </summary>
        internal static Exception UserDefinedOpMustHaveConsistentTypes(object p0, object p1)
        {
            return new ArgumentException(Strings.UserDefinedOpMustHaveConsistentTypes(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "The user-defined operator method '{1}' for operator '{0}' must return the same type as its parameter or a derived type."
        /// </summary>
        internal static Exception UserDefinedOpMustHaveValidReturnType(object p0, object p1)
        {
            return new ArgumentException(Strings.UserDefinedOpMustHaveValidReturnType(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "The user-defined operator method '{1}' for operator '{0}' must have associated boolean True and False operators."
        /// </summary>
        internal static Exception LogicalOperatorMustHaveBooleanOperators(object p0, object p1)
        {
            return new ArgumentException(Strings.LogicalOperatorMustHaveBooleanOperators(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "No method '{0}' exists on type '{1}'."
        /// </summary>
        internal static Exception MethodDoesNotExistOnType(object p0, object p1)
        {
            return new InvalidOperationException(Strings.MethodDoesNotExistOnType(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "No method '{0}' on type '{1}' is compatible with the supplied arguments."
        /// </summary>
        internal static Exception MethodWithArgsDoesNotExistOnType(object p0, object p1)
        {
            return new InvalidOperationException(Strings.MethodWithArgsDoesNotExistOnType(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "No generic method '{0}' on type '{1}' is compatible with the supplied type arguments and arguments. No type arguments should be provided if the method is non-generic. "
        /// </summary>
        internal static Exception GenericMethodWithArgsDoesNotExistOnType(object p0, object p1)
        {
            return new InvalidOperationException(Strings.GenericMethodWithArgsDoesNotExistOnType(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "More than one method '{0}' on type '{1}' is compatible with the supplied arguments."
        /// </summary>
        internal static Exception MethodWithMoreThanOneMatch(object p0, object p1)
        {
            return new InvalidOperationException(Strings.MethodWithMoreThanOneMatch(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "More than one property '{0}' on type '{1}' is compatible with the supplied arguments."
        /// </summary>
        internal static Exception PropertyWithMoreThanOneMatch(object p0, object p1)
        {
            return new InvalidOperationException(Strings.PropertyWithMoreThanOneMatch(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "An incorrect number of type args were specified for the declaration of a Func type."
        /// </summary>
        internal static Exception IncorrectNumberOfTypeArgsForFunc(string paramName)
        {
            return new ArgumentException(Strings.IncorrectNumberOfTypeArgsForFunc, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "An incorrect number of type args were specified for the declaration of an Action type."
        /// </summary>
        internal static Exception IncorrectNumberOfTypeArgsForAction(string paramName)
        {
            return new ArgumentException(Strings.IncorrectNumberOfTypeArgsForAction, paramName);
        }
        /// <summary>
        /// ArgumentException with message like "Argument type cannot be System.Void."
        /// </summary>
        internal static Exception ArgumentCannotBeOfTypeVoid(string paramName)
        {
            return new ArgumentException(Strings.ArgumentCannotBeOfTypeVoid, paramName);
        }
        /// <summary>
        /// ArgumentOutOfRangeException with message like "{0} must be greater than or equal to {1}"
        /// </summary>
        internal static Exception OutOfRange(string paramName, object p1)
        {
            return new ArgumentOutOfRangeException(Strings.OutOfRange(paramName, p1), paramName);
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot redefine label '{0}' in an inner block."
        /// </summary>
        internal static Exception LabelTargetAlreadyDefined(object p0)
        {
            return new InvalidOperationException(Strings.LabelTargetAlreadyDefined(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot jump to undefined label '{0}'."
        /// </summary>
        internal static Exception LabelTargetUndefined(object p0)
        {
            return new InvalidOperationException(Strings.LabelTargetUndefined(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "Control cannot leave a finally block."
        /// </summary>
        internal static Exception ControlCannotLeaveFinally()
        {
            return new InvalidOperationException(Strings.ControlCannotLeaveFinally);
        }
        /// <summary>
        /// InvalidOperationException with message like "Control cannot leave a filter test."
        /// </summary>
        internal static Exception ControlCannotLeaveFilterTest()
        {
            return new InvalidOperationException(Strings.ControlCannotLeaveFilterTest);
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot jump to ambiguous label '{0}'."
        /// </summary>
        internal static Exception AmbiguousJump(object p0)
        {
            return new InvalidOperationException(Strings.AmbiguousJump(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "Control cannot enter a try block."
        /// </summary>
        internal static Exception ControlCannotEnterTry()
        {
            return new InvalidOperationException(Strings.ControlCannotEnterTry);
        }
        /// <summary>
        /// InvalidOperationException with message like "Control cannot enter an expression--only statements can be jumped into."
        /// </summary>
        internal static Exception ControlCannotEnterExpression()
        {
            return new InvalidOperationException(Strings.ControlCannotEnterExpression);
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot jump to non-local label '{0}' with a value. Only jumps to labels defined in outer blocks can pass values."
        /// </summary>
        internal static Exception NonLocalJumpWithValue(object p0)
        {
            return new InvalidOperationException(Strings.NonLocalJumpWithValue(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "Extension should have been reduced."
        /// </summary>
        internal static Exception ExtensionNotReduced()
        {
            return new InvalidOperationException(Strings.ExtensionNotReduced);
        }
        /// <summary>
        /// InvalidOperationException with message like "CompileToMethod cannot compile constant '{0}' because it is a non-trivial value, such as a live object. Instead, create an expression tree that can construct this value."
        /// </summary>
        internal static Exception CannotCompileConstant(object p0)
        {
            return new InvalidOperationException(Strings.CannotCompileConstant(p0));
        }
        /// <summary>
        /// NotSupportedException with message like "Dynamic expressions are not supported by CompileToMethod. Instead, create an expression tree that uses System.Runtime.CompilerServices.CallSite."
        /// </summary>
        internal static Exception CannotCompileDynamic()
        {
            return new NotSupportedException(Strings.CannotCompileDynamic);
        }
        /// <summary>
        /// InvalidOperationException with message like "Invalid lvalue for assignment: {0}."
        /// </summary>
        internal static Exception InvalidLvalue(ExpressionType p0)
        {
            return new InvalidOperationException(Strings.InvalidLvalue(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "Invalid member type: {0}."
        /// </summary>
        internal static Exception InvalidMemberType(object p0)
        {
            return new InvalidOperationException(Strings.InvalidMemberType(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "unknown lift type: '{0}'."
        /// </summary>
        internal static Exception UnknownLiftType(object p0)
        {
            return new InvalidOperationException(Strings.UnknownLiftType(p0));
        }
        /// <summary>
        /// ArgumentException with message like "Cannot create instance of {0} because it contains generic parameters"
        /// </summary>
        internal static Exception IllegalNewGenericParams(object p0, string paramName)
        {
            return new ArgumentException(Strings.IllegalNewGenericParams(p0), paramName);
        }
        /// <summary>
        /// InvalidOperationException with message like "variable '{0}' of type '{1}' referenced from scope '{2}', but it is not defined"
        /// </summary>
        internal static Exception UndefinedVariable(object p0, object p1, object p2)
        {
            return new InvalidOperationException(Strings.UndefinedVariable(p0, p1, p2));
        }
        /// <summary>
        /// InvalidOperationException with message like "Cannot close over byref parameter '{0}' referenced in lambda '{1}'"
        /// </summary>
        internal static Exception CannotCloseOverByRef(object p0, object p1)
        {
            return new InvalidOperationException(Strings.CannotCloseOverByRef(p0, p1));
        }
        /// <summary>
        /// InvalidOperationException with message like "Unexpected VarArgs call to method '{0}'"
        /// </summary>
        internal static Exception UnexpectedVarArgsCall(object p0)
        {
            return new InvalidOperationException(Strings.UnexpectedVarArgsCall(p0));
        }
        /// <summary>
        /// InvalidOperationException with message like "Rethrow statement is valid only inside a Catch block."
        /// </summary>
        internal static Exception RethrowRequiresCatch()
        {
            return new InvalidOperationException(Strings.RethrowRequiresCatch);
        }
        /// <summary>
        /// InvalidOperationException with message like "Try expression is not allowed inside a filter body."
        /// </summary>
        internal static Exception TryNotAllowedInFilter()
        {
            return new InvalidOperationException(Strings.TryNotAllowedInFilter);
        }
        /// <summary>
        /// InvalidOperationException with message like "When called from '{0}', rewriting a node of type '{1}' must return a non-null value of the same type. Alternatively, override '{2}' and change it to not visit children of this type."
        /// </summary>
        internal static Exception MustRewriteToSameNode(object p0, object p1, object p2)
        {
            return new InvalidOperationException(Strings.MustRewriteToSameNode(p0, p1, p2));
        }
        /// <summary>
        /// InvalidOperationException with message like "Rewriting child expression from type '{0}' to type '{1}' is not allowed, because it would change the meaning of the operation. If this is intentional, override '{2}' and change it to allow this rewrite."
        /// </summary>
        internal static Exception MustRewriteChildToSameType(object p0, object p1, object p2)
        {
            return new InvalidOperationException(Strings.MustRewriteChildToSameType(p0, p1, p2));
        }
        /// <summary>
        /// InvalidOperationException with message like "Rewritten expression calls operator method '{0}', but the original node had no operator method. If this is intentional, override '{1}' and change it to allow this rewrite."
        /// </summary>
        internal static Exception MustRewriteWithoutMethod(object p0, object p1)
        {
            return new InvalidOperationException(Strings.MustRewriteWithoutMethod(p0, p1));
        }
        /// <summary>
        /// NotSupportedException with message like "TryExpression is not supported as an argument to method '{0}' because it has an argument with by-ref type. Construct the tree so the TryExpression is not nested inside of this expression."
        /// </summary>
        internal static Exception TryNotSupportedForMethodsWithRefArgs(object p0)
        {
            return new NotSupportedException(Strings.TryNotSupportedForMethodsWithRefArgs(p0));
        }
        /// <summary>
        /// NotSupportedException with message like "TryExpression is not supported as a child expression when accessing a member on type '{0}' because it is a value type. Construct the tree so the TryExpression is not nested inside of this expression."
        /// </summary>
        internal static Exception TryNotSupportedForValueTypeInstances(object p0)
        {
            return new NotSupportedException(Strings.TryNotSupportedForValueTypeInstances(p0));
        }

        /// <summary>
        /// InvalidOperationException with message like "Dynamic operations can only be performed in homogeneous AppDomain."
        /// </summary>
        internal static Exception HomogeneousAppDomainRequired()
        {
            return new InvalidOperationException(Strings.HomogeneousAppDomainRequired);
        }
        /// <summary>
        /// ArgumentException with message like "Test value of type '{0}' cannot be used for the comparison method parameter of type '{1}'"
        /// </summary>
        internal static Exception TestValueTypeDoesNotMatchComparisonMethodParameter(object p0, object p1)
        {
            return new ArgumentException(Strings.TestValueTypeDoesNotMatchComparisonMethodParameter(p0, p1));
        }
        /// <summary>
        /// ArgumentException with message like "Switch value of type '{0}' cannot be used for the comparison method parameter of type '{1}'"
        /// </summary>
        internal static Exception SwitchValueTypeDoesNotMatchComparisonMethodParameter(object p0, object p1)
        {
            return new ArgumentException(Strings.SwitchValueTypeDoesNotMatchComparisonMethodParameter(p0, p1));
        }
        /// <summary>
        /// NotSupportedException with message like "DebugInfoGenerator created by CreatePdbGenerator can only be used with LambdaExpression.CompileToMethod."
        /// </summary>
        internal static Exception PdbGeneratorNeedsExpressionCompiler()
        {
            return new NotSupportedException(Strings.PdbGeneratorNeedsExpressionCompiler);
        }

        /// <summary>
        /// The exception that is thrown when the value of an argument is outside the allowable range of values as defined by the invoked method.
        /// </summary>
        internal static Exception ArgumentOutOfRange(string paramName)
        {
            return new ArgumentOutOfRangeException(paramName);
        }

        /// <summary>
        /// The exception that is thrown when an invoked method is not supported, or when there is an attempt to read, seek, or write to a stream that does not support the invoked functionality.
        /// </summary>
        internal static Exception NotSupported()
        {
            return new NotSupportedException();
        }

#if FEATURE_COMPILE
        /// <summary>
        /// NotImplementedException with message like "The operator '{0}' is not implemented for type '{1}'"
        /// </summary>
        internal static Exception OperatorNotImplementedForType(object p0, object p1)
        {
            return NotImplemented.ByDesignWithMessage(Strings.OperatorNotImplementedForType(p0, p1));
        }
#endif

        /// <summary>
        /// ArgumentException with message like "The constructor should not be static"
        /// </summary>
        internal static Exception NonStaticConstructorRequired(string paramName)
        {
            return new ArgumentException(Strings.NonStaticConstructorRequired, paramName);
        }

        /// <summary>
        /// InvalidOperationException with message like "Can't compile a NewExpression with a constructor declared on an abstract class"
        /// </summary>
        internal static Exception NonAbstractConstructorRequired()
        {
            return new InvalidOperationException(Strings.NonAbstractConstructorRequired);
        }
    }
}

redpajama_set_name: RedPajamaGithub


There's probably nobody in america, who hasn't witnessed the ongoing, constant debate about healthcare, about the best possible plan of action.
While there have been several views about the Affordable Care Act (also called the ACA, or Obamacare), and also a fair evaluation would indicate both advantages, in addition to drawbacks, the present politically motivated effort to re – define our healthcare system, may, or may not, also, be focused on enhancing, and/ or doing what's in the best interests of many Americans.
When we have a President, who is apparently disinterested in keeping reality, and makes contradictory statements, it becomes easier, to recognize some of the inherent challenges!
This President bragged, during his campaign, he was the only Republican candidate, running, who wouldn't touch Social Security, Medicare or Medicaid, someone who might not even have read reviews for exposed skin care, nevertheless, the existing proposals, both the one approved by the House of Representatives, and the one being discussed by the Senate, are straight tweaking Medicaid, and, maybe, others, also!
1. Most individuals aren't sure, and it seems, neither is Mr. Trump! I recently saw a statistic which Medicaid was, undoubtedly, the biggest insurer, for childbirth, children with disabilities, and adults with disabilities.
2. However, in order to get a single individual, to qualify for these subsidies, he must be getting under $42,000 each year! In many states, particularly with people with higher costs of living, taxes, etc, those limits are both unrealistic, and, possibly, even Draconian! Is the intention of this legislation, to create a better system, which will make prices lower, and provide much better reporting, and save the government money, or is it only, an effort to reduce the taxes for the wealthiest Americans? When one considers, healthcare represents around 15 percent, or more of the general economy, should not we seek the best, as opposed to a fake, politically – motivated work?
3. Repeal and replace, versus tweak and enhance: If the proposal doesn't do what it promised to do, and does more for lowering particular constituents taxes, than enhancing healthcare, should not the attempt have been, to discover improvements, enhancements, and so on, and tweak the current plan, instead?
4. The faulty reasoning concerning mandating health insurance buying: While it may sound nice, to remove these mandates, if the smallest risk people, are eliminated in the general pool, rates will rise! It is simple mathematics and economics!
5. Funding: What actual, long – term improvements, to the medical system, are made, due to these proposals? This is but a cursory view of a challenging issue! If it took close to a year, to pass the Affordable Care Act, and there were still many problems, which needed fixing, does not it make sense, any alternative/ replacement, should be openly, thoroughly discussed, in public, instead of behind closed doors?
← Politics and issue's: What Does it Mean to You ?


text:
Free Custom «Human Nature and War» Essay Paper
Human Nature and War essay
For centuries, war and violence have been used by human beings for a number of reasons. For the ancient generations, war and violence were used for the purpose of defending people's territories and other interests, to seize natural resources, and for reproduction. In the modern societies, war and violence serve nations in protecting their territorial integrity, protesting poor leadership/injustices, and for issues of the national security. There is a general consensus when it comes to the purpose of war and violence in the society, but when it comes to explaining the source of war and violence in humans, human nature theorists and cognitive theorists diverge greatly. For human nature theorists, war and violence are natural human instincts, and the state provides avenues through which these impulses can be channeled. On the other hand, cognitive theorists believe that war and violence are the learned human behaviors, which can be potentially unlearned and relearned according to different circumstances. This essay explores the arguments presented by the two groups of theorists, and in the following discussions, it will become clear that cognitive theorists provide a more compelling explanation for war and violence in humans.
Human Nature and War
War and other acts of violence are used by human beings for a variety of reasons. First and foremost, human beings use war and violence to defend themselves and their interests from external attacks. Secondly, war and violence has been used for centuries to seize material wealth and natural resources in different communities. Thirdly, studies indicate that certain groups of people have long used war and violence to impose their beliefs and values on other groups. Fourthly, war and violence can be used by citizens of a given state to protest against poor leadership and other forms of injustices. Lastly, people can use war and violence as a way of finding relief from boredom and disrupting the existing peace (Wilson, 1978).
Despite that the reasons behind human involvement in war and violence are well known, international relations theorists are divided when it comes to arguing for violence and war in human beings. One group of theorists who are better referred to as human nature theorists argue that violence and war are innate characteristics of humans, which occur in the form of violent impulses. These violent impulses can be channeled through the state, which in this case constitutes a group of people drawn from a specific geographic location or those sharing similar beliefs. On the other hand, a group of cognitive theorists argue that war and violence are the learned human behaviors, but they are not instinctual in nature. Moreover, cognitive theorists believe that violent behaviors in human beings can be unlearned or relearned at times. This essay examines the explanations provided by the two groups of theorists with the aim of showing that cognitive theorists provide a more compelling argument for violence and war in human beings.
The Human Nature Theory
As noted earlier, the human nature theory holds that war and violence are the innate human behaviors, which can be channeled through the state or other modern institutions. Most human nature theorists have provided a variety of compelling reasons in favor of their case. Accordingly, Pinker (2007) argues that there has been a decline in violence over the centuries due to changes in people's willingness to act on their violent impulses. In fact, Pinker notes that over 80 percent of people in modern societies fantasize about killing the people they hate. Furthermore, people in modern societies enjoy viewing violence through Shakespearean dramas, video games, violent movies, and other forms of sports entertainment. These acts according to Pinker (2007) serve to show that human beings are violent by nature. However, due to the existence of more stable and centralized states, which promote peace among the people besides exerting control over resources, the avenues through which people could channel their violent impulses have been narrowed. Moreover, through civilization, which is marked by high levels of self-control, sensitivity for other people's feelings, and long-term planning, people have come to embrace peace. Additionally, in many civilized states, violence and war have been averted by imposing penalties on different violent acts and removing the incentives for aggression among the people. But, in the failed states and collapsed empires, violence is a reality because there are no systems in place to avert the tragedies of violence (Pinker, 2007).
Another human nature theorist has examined aggression from a socio-biological perspective. Accordingly, Wilson (1978) notes that human beings are innately aggressive considering that warfare has been in existence since the early hunter-gatherer societies to the modern, more civilized and industrial states. Here, Wilson indicates that innateness refers to the likelihood that the aggressiveness trait/behavior will develop in the specified environments, but not in all environments. This implies that the aggressive behavior is hereditary in human beings. In fact, Wilson (1978) notes that the most peaceful societies today were the most aggressive years ago, and there is a great probability that they can turn violent in the future. However, it is important to note that despite the innateness of the aggressive trait in humans; almost all societies have developed systems that sanction the commission of violent acts including rape, murder, war, and extortion. Through these sanctions, states have been capable of averting inevitable forms of conflicts within and outside their respective territories. However, it is equally important to indicate that human aggression differs greatly from aggression in other mammals. In human beings, aggressive impulses appear and disappear with respect to different circumstances. Moreover, Wilson (1978) indicates that human aggression involves ill-defined responses connected to separate controls in the brain. Generally, human beings will respond aggressively with the aim of defending themselves, conquering and protecting territories, asserting dominance over others, and for defensive counterattacks. Furthermore, these categories of aggressive behaviors can be added, modified, or removed at any time during the human lifespan.
Along the same perspective, Stoessinger (2005) notes that aggression is an inherent part of human nature as opposed to war, which is a habit that can be learned and unlearned according to particular circumstances. Here, it is important to note that human beings have overcome some habits such as incest, cannibalism, and slavery, which were once considered as human nature. However, Stoessinger (2005) is quick to add that some human habits can only be abandoned after a catastrophe strikes. Most importantly, Stoessinger examines the causes of war in the twenty first century and notes that national leaders' personalities play a central role in precipitating wars in the contemporary societies. Here, the world leaders tend to misperceive the character, intentions, and capabilities of their adversaries. Therefore, leaders will approach war with a lot of optimism, which turns into a powerful emotional impetus that causes war between nations. Moreover, the distorted perceptions about the adversary's character tend to precipitate conflicts among national leaders, which then escalate into full scale wars between nations. On the other hand, when leaders misperceive the intentions of their adversaries, there is a high probability that war will break out. As a result, the national leaders' self-delusions can precipitate wars considering that they bear great responsibility in mobilizing support for issues of national interest. This implies that an individual's innate aggressive behavior and fear can be turned into a full scale war and violence by making other people believe in them (Stoessinger, 2005).
On the other hand, Lorenz (1963) has examined the importance of aggression in intra-specific preservation. Here, aggression forms an integral part of the life-preserving instincts, which allow different species to fight each other for survival, territorial preservation, and protection of the young. Specifically, aggression is an innate behavior shown by members of a particular species when they are under threat, and it is central to species preservation. However, the significant changes to environmental conditions brought about by mankind threaten the life-preserving role of aggression. Here, it is important to note that the end results of man's intelligence such as the development of the atomic bomb coupled with the innate aggressive behavior cannot predict a long life for mankind. As a result, aggression has been reduced to a pathological product of man's disorganized cultural and social life. Furthermore, Lorenz (1963) notes that aggression is a spontaneous and hence, dangerous instinct because it does not involve reactions to particular external factors. Thus, aggression in the contemporary societies is facilitated by lack of the social contact and it occurs spontaneously.
In examining the dark side of mankind with the aim of tracing the roots of male violence, Ghiglieri (2000) found out that men and women are different because they are genetically programmed to learn different gender roles that will benefit them. Here, men participate in highly competitive roles such as hunting, fighting, and politics with the aim of controlling resources, which are central to attracting and supporting their female counterparts. As a result, Ghiglieri (2000) notes that men tend to perform these roles violently, especially by killing, robbing, and waging war against their competitors. Therefore, women and men are naturally designed to be different in sex and gender besides being instinctively designed to take up gender roles that are culturally appropriate for purposes of reproductive competition with members of the same sex. Accordingly, violence in men will emerge as a competitive reproductive strategy aimed at giving them a competitive advantage over other people of the same sex. This implies that male violence is an innate human behavior that is shaped by nature, sex, nurture, and gender. Specifically, aggression in men is programmed by the human genes and hence it is common to find out that weapon making is dominated by males in different societies. However, through socialization, men are thought when and how to use their weapons among other forms of violence (Ghiglieri, 2000).
The same argument provided by human nature theorists is held by evolutionary psychologists who argue that the human brain comprises domain-specific mechanisms including the evolved psychological mechanisms, which are responsible for registering specific inputs, processing them, and generating specific responses. Some of the most basic psychological mechanisms that have evolved over the years are those related to recurrent problems in the society such as finding food and shelter, searching for mates, avoiding predators, and protecting the offspring. In some instances, evolved psychological mechanisms may cause maladaptive behaviors in the modern societies, particularly when novel impulses are sent to the brain. For instance, human beings will experience fear in the presence of stimuli, which have long been considered threats throughout the human evolutionary history even though they are no longer potent threats in the modern society. In the same way, human beings in the contemporary societies will respond with violence when they encounter novel environmental inputs that were long considered threats throughout the human evolutionary history (Liddle, Shackelford, & Weekes-Shackelford, 2012). Thus, genes play a major role in initiating a variety of behaviors in the contemporary societies, but their interactions with the external environment should not be overlooked.
The Cognitive Theory
As indicated earlier, the cognitive theory holds that human violence is a learned behavior, but not an instinct, and hence, it can be unlearned or relearned according to particular circumstances. According to Fry (2007), it is wrong to assume that violence and war are inevitable human behaviors and that human societies anywhere in the world will wage war spontaneously. By examining the human potential to make peace, Fry indicates that the twenty first century provides human beings with enough challenges and opportunities to seek peace and justice even though the ways of doing so vary greatly. In some cases, people will seek justice through violence, but most people do not use violence. In fact, Fry (2007) notes that the most violent acts are associated with people defending their basic rights or those opposed to extreme injustices. Otherwise, a variety of anthropological and historical studies have shown that humans have the ability to replace violence with other means of seeking justice, which involve non-violent actions. Here, anthropologists indicate that violence and war can be unlearned in the presence of more effective, non-violent means of seeking justice, providing security, and defending rights.
Another cognitive theorist has examined the issue of the increased militarism in America in relation to war and violence. According to Fahey, the American society has seen an increase in the influence of the military in almost all spheres of life including economic, political, social, and spiritual. The increased support for peacetime military establishment not only drains resources meant for social programs, but it also increases the likelihood of the world wars and violence in the society (Defense Monitor Staff, 1992). In fact, the movie, "Soldiers of Conscience" has shown that war and violence are the learned human behaviors, and not instincts. The movie profiles the experience of eight U.S. soldiers who are wrestling with the idea of having killed another human being. This film explores human nature and war, and it confirms the results of a previous study from World War II, which found out that more than 75 percent of combat soldiers may not kill another human being, despite there is an opportunity to do so. This indicates that human beings maintain restraint when it comes to taking another person's life (National PBS Broadcast, 2008).
Yet, in a study examining the relationship between personality, combat exposure, and wartime atrocities in the Vietnam War, Holowka et al. (2012) found out that combat exposure is strongly related to participation in wartime atrocities by military personnel. Furthermore, the study findings demonstrated that combat exposure could be mediating the relationship between trait neuroticism and commission of wartime atrocities. Therefore, the researchers concluded that combat exposure and personality are important risk factors in the commission of wartime atrocities by military personnel. Generally, the foregoing case studies indicate that human beings despite possessing the ability to remain peaceful can turn violent when circumstances call for such a response. Along the same perspective, Floyd (2010) notes that war is an unnatural human act with deleterious effects that spun generations and in most cases, the effects of war may not be remedied by victory. Nonetheless, human beings will always praise militarism and dishonor peaceful ways when faced with acts of extreme violence, and hence, military power is a central attribute of the contemporary society. As a result, war is celebrated and appreciated in the society because the aggressors will always indicate that their cause is just while demonizing their perceived or suspected enemies. This implies that the majority are led to believe that it is only through war that they can overcome their economic, social, and sometimes, spiritual problems. Overall, war becomes a learned behavior in the society (Floyd, 2010).
On the other hand, Grossman (2009) notes that death and killing have been vital, essential, and common occurrences in human history. Moreover, death and killing were central to daily human existence despite being messy and boring to participate in or even to watch. However, in the last few generations, death and killing for daily human existence has become a thing of the past. In fact, death and killing are serious offenses in the contemporary society, and they can attract unbearable punishments including verbal and physical attacks. Yet, people in the modern society embrace violent and brutal deaths and killings through movies and sports entertainment (Grossman, 2009). This can only serve to indicate that war and violence are the learned human behaviors, which can be potentially unlearned and relearned with respect to different circumstances. From another perspective, Hermann (2005) indicates that global leaders influence the lives of their followers in such a way that their preferences, beliefs, and decisions will always resonate with those of the entire public. By profiling national leaders such as Saddam Hussein, Tony Blair, and Bill Clinton, Hermann (2005) manages to demonstrate the influence of leaders and their leadership styles on the entire populations. Here, it is important to note that national leaders are involved in decision- and policy-making for domestic and international purposes. Moreover, these leaders are involved in the implementation of the decisions either directly or by delegating duties to their junior staff. Consequently, if these national leaders believe in war as the only way toward restoring peace and tranquility within their borders, then it follows that their junior staff and the entire nation will rally behind them. Hence, by exerting control and influence on their followers, national leaders take a pro-active role in ensuring that the public appreciates the importance of war for different purposes. As a result, war becomes a learned behavior among the people who are otherwise peaceful under normal circumstances.
For Zinn (1990), war and violence can never be natural human instincts. Accordingly, Zinn notes that people have been made to believe that human beings are naturally violent and bad through a variety of self-fulfilling prophecies. Therefore, when one is persuaded that it is human nature to be violent and bad, it does not take much for this individual to think and act that way while blaming it all on human nature. Furthermore, Zinn (1990) indicates that there is no concrete evidence to suggest that war and violence are human instincts. In other words, humans are not innately aggressive considering that most forms of human violence and aggression do not arise from the inborn drives. As a result, since neither biology nor psychology can provide evidence in favor of the innateness of war and violence, Zinn (1990) concludes that these human behaviors are learned, but not inborn. Here, it is imperative to note that modern culture provides a variety of opportunities for people to learn about war and violence. In so doing, these people come to appreciate war and violence as the possible ways of solving certain problems. On the other hand, Kahan (2010) indicates that given scientific evidence regarding risky social issues such as war and violence, people will always side with the position that strengthens their connection with a large group of people, preferably their kin or countrymen. In fact, empirical evidence has shown that the same groups will agree or disagree on cultural issues as a block. This group of influence can be seen as a great opportunity for people to appreciate and embrace war and violence if only their position will serve to reinforce the relationship with other people, particularly with those with whom they share important commitments. Furthermore, in democratic societies, leaders exploit group influence in getting people to accept their decisions through imperfect ways of distributing information (Kahan, 2010). Overall, it is safe to conclude that war and violence are the learned human behaviors from this perspective.
From the foregoing discussions, it is evident that the cognitive theory provides a more compelling explanation for war and violence in human beings. In fact, it is true that war and violence can never be natural human instincts, but the learned human behaviors, which have been handed down from generation to generation with a variety of improvements along the way. For the ancient generations, it is true that war and violence developed as a result of the need to defend territories, seize natural resources, reproduce, and protect their children. However, in modern societies, war and violence are behaviors learned from the popular media and other global leaders, whose influence on their followers means a lot. Therefore, when people are made to believe that war and violence are possible ways in addressing their economic, social, and spiritual issues, then it does not take much for these people to embrace and participate in war and violence. Moreover, if a national leader believes that there are enough reasons for his country to go to war with another country, it does not cost a penny in getting the general public to rally behind his decision. Furthermore, people tend to take sides with the most popular decisions so long as their position serves to reinforce their connection to other people with whom they share important commitments. Thus far, it is safe to conclude that war and violence are the learned human behaviors, and not instincts as proposed by the human nature theory.
Related History essays
Post Chinese 1949 Era In Relation To Conjugal and Patriarchal Relationships essay
The UK Human Rights Law essay
Civil War Analysis essay
American History Development essay
An Assessment of England through the Changing Times essay
The war between the Mexican government and the United States essay
Ancient Greece essay
Mexican American depression essay
Europe in the High Middle Ages essay

redpajama_set_name: RedPajamaCommonCrawl


Here's a sneak peek at some photos I'll be posting soon from a Vancouver actor headshots session we did a couple of weeks ago with model Ravi Bansal and Vancouver Makeup Artist Donika Rudari. These photos were done in studio with Donika doing makeup, hair, and wardrobe styling. More photos from this portfolio session to come in a future post.


Is this possible to locate practical company development tips within the Bible? Does the different teachings associated with Jesus Christ possess anything related to how a small company operator may take his / her business to another level?
Have a person operated your company for several years now but you continue to be finding this tough getting away from debts? If you would like business improvement secrets that will help to flourish in business, then you definitely are reading the best article. I'll be describing 5 useful bible secrets for the business development.
Christ, the Son from the Living Lord arrived this particular world and decided on a manger because His delivery place! What a method to start for that One the master of the earth and it is fullness thereof!
Your small company today may become a excellent one the next day. Therefore, you shouldn't be frightened of beginning small. It's also wise to not shed courage when it appears things aren't working the way in which it ought to.
Most aspiring business owners wrongly believe starting a company is the actual ticket to managing a successful company. The truth from the matter is actually that beginning your company on a little scale may be the better technique to achieving long lasting success.
PZ Cussons Plc, the huge producer associated with quality personal maintenance systems started away by delivery palm essential oil, palm kernels, cacao, seed cottons, floor nuts, in addition to animal conceals and skin to the uk. This exercise gave them the chance to obtain the required experience in conducting business profitably within Africa.
The sensible men required to locate Christ, the Saviour from the world which had simply been born to the world however they had no concept of where His host to birth had been. God supplied Jesus like a solution towards the world's issue. The exact same God found the rescue from the wise males by creating a star in order to announce the actual birth associated with Jesus as well as led the actual wise males to exactly where He had been (Matthew two: 10).
If you have provided an answer to an issue, package this and please allow world learn about it. This is actually the only way they are able to work with you. I am certain you realize that your company improves when many individuals know regarding and patronise your services and products. How would you make the folks to learn about you and also the problem you've solved? This really is through well-targeted advertising activities. Properly carried out marketing actions will draw individuals to your location similar to the star introduced the wisemen towards the birth host to Jesus.
Production isn't complete when the product your company is offering doesn't reach it's customers. The minds behind BOC Team Plc recognized this and in order to ensure effective and efficient distribution associated with its gasoline in 1887, they began granting permit to impartial companies throughout The uk to create oxygen below its procedure.
In the actual 50s, additionally they built tonnage vegetation on or near to customer websites. Customers had a chance to know regarding their products which did lots of good for their business.
Solution 3: What's Your Dominating Business?
Jesus found this world having a 'dominant profession' – in order to save His people using their sins. He in no way lost focus of the major task. He cured the ill, fed the actual hungry, quenched the actual thirst from the thirsty as well as taught both old and also the young concerning the kingdom associated with God. Nevertheless, His main assignment associated with saving Their people had been always His main concern.
Your business must have a dominating assignment from inception. You have to define it before you begin or a person redefine it for those who have lost concentrate.
Intel Company, reputed to become the biggest semi conductor manufacturer on the planet devoted much focus on their top product — micro processors. This assisted greatly throughout the depression these people faced in the centre 1980s. The primary product continued to be highly profitable also it helped to create back the organization to life in most areas.
God, the father Jesus, Saviour from the world originated from the little town associated with Bethlehem.
Bethlehem, based on the Bible passing above had been small one of the clans associated with Judah. Nicely, the great news for you out of this is how the small city of Bethlehem produced the truly amazing messiah that could save the planet from sin!
Regardless of how very humble your history is or even how monetarily weak you're, you may still release out right into a business as well as grow it to become force to become reckoned with in the commercial world.
In the event that Bethlehem created the messiah, you'll be able to also perform exploits running a business, your history not withstanding.
Bob Gardener, the actual founder associated with Gardner Wealthy & company. – the multi-million buck stock broker agent firm in the united states has really humble starting. Born since the only son inside a family associated with twelve kids, his first couple of years were full of nothing however difficulty as well as uncertainty.
These days, Chris mind a thriving brokerage firm and it is presently busy focusing on what he or she considers the largest deal associated with his profession – he's setting upward an expense venture within South Africa that will go quite a distance to internet him big profit on the consistent foundation.
Could it be not interesting to notice that Frederick and Jane got themselves involved with so a lot activities they were not aware that small Jesus remained behind within Jerusalem once they had remaining. The Holy bible says "they believed he is at their organization and travelled for any day prior to they realized their mistakes" (V44).
These were without Christ (a present to the planet) for any day!
Do you receive yourself involved with so numerous activities that won't do worthwhile to your company? It is about time you experienced a rethink and obtain settled to complete only stuff that will improve your company.
Huge success running a business comes when you'll want established your company as a specialist in a place. For you to definitely develop this particular needed professional position, you have to be concentrated and still do that which you are greatest at performing.


At Finn Hill Animal Hospital, our goal is to help all your canine and feline friends lead happy and healthy lives. It's why we strongly recommend that all pet owners have their cats and dogs spayed or neutered. These procedures have been shown to have many benefits for the health and longevity of your animal, as well as beneficial effects for the community as a whole.
Though any surgery requiring anesthesia does come with some risks, the complications associated with spaying and neutering are extremely low. We tailor every procedure to safely meet each pet's individual needs. Before the procedure, our veterinarian will perform some tests to ensure your pet's overall health and answer any questions you may have. Once your pet is placed under anesthesia, we use constant vital monitoring systems to maintain a stable heart rate and respiration throughout. When the procedure is all done, they'll wake up and recover with our team before we send them home with you.
Common side effects following sedation include mild lethargy and grogginess. Your pet may also be tempted to lick or scratch at the surgical incision site, so it'll be important to use a shirt or collar to protect any incisions while they heal.
We strongly recommend spaying or neutering as part of your pet's lifelong health and wellness plan. In female cats and dogs, spaying has been associated with a reduced risk of breast cancer and ovarian tumors. Spayed females also do not go into heat, avoiding the characteristic discharge, excessive licking, and aggression. In males, neutering significantly reduces the risk of both prostate enlargement and testicular cancer. Neutered pets also tend to show fewer behavioral problems, including territorial marking, barking, roaming, and aggression. Beyond that, pet overpopulation leads to millions of animals being euthanized each year in the US. Spaying and neutering your animal really makes a difference in the community.
Finn Hill Animal Hospital offers animal spay & neuter procedures in the Kirkland, Mill Creek, Woodinville, Bothell, Kenmore, Kingsgate, Mountlake Terrace, Totem Lake, Redmond, Lake Forest Park and the surrounding communities.


The Busted ATV Resort is located only a half mile away from the Hatfield and McCoy Trail head. The Hatfield and McCoy trail system is one of the largest in the world, here you can find over 700+ miles of off-road trails for every skill level. Many of these trails also connect riders to some of West Virginia's ATV friendly towns where you can take a break and grab some food. The trails are open 365 days a year.
The Hatfield and McCoy trails have been recognized and praised by Dirt Wheels, ATV Illustrated, ATV Sport, Dirt Rider and ATV Magazine, as well as television features on programs such as Fishers ATV World, Dirt Trax TV and more.
All rider must have a valid permit before using the Hatfield & McCoy trails.
Permits can be purchased Online.
Everyone must wear a DOT or SNELL approved helmet and eye protection.
All operators and passengers on an ATV, UTV, or motorcycle must follow manufacturers recommendations.
All operators and passengers on an ATV, UTV, or motorcycle must meet manufacturers minimum age requirements.
Adult supervision is required for those under age 16.
Do not leave any trash or litter behind.
Stay alert at all times, be aware of oncoming traffic.
Trails only open during daylight hours.
ORVs are permitted on the Ivy Branch system only.
A valid drivers license is required to operate an ORV.
All passengers must be over 8 years of age, or 4í9î tall. No booster or car seats are allowed.
Possess a valid owners manual for the machine being operated that is able to be produced upon request.
UTVs must be equipped with a steering wheel and roll-over protection system from the manufacturer. Low pressure tires required 20psi at manufacturers recommended inflation.
Riding your ATV on the roads.
West Virginia allows you to ride up to ten miles on any road for lodging, gas and food.


Recently released data by the National Crime Records Bureau shows that fifteen people commit suicide every hour in India. Of these, around 17% are housewives.
The NCRB divides the total suicides into 10 professional categories — housewife, service (government), service (private), public sector undertaking, student, unemployed, self-employed (business activity), farming/agriculture activity, retired and others.
The data shows that 1.3 lakh people committed suicide in 2013. Among suicides by women, a whopping 51.4% are committed by housewives (almost 23,000).
The previous Census in 2011 recorded that 52% of India's population married at least once. The 2013 NCRB data shows that a whopping 76 per cent of all suicides are by people who have married at least once.
According to some experts, the stress and pressures faced by housewives are a leading cause of suicide. This problem is exacerbated by modern lifestyles and occupations. To compound this problem, social stigma surrounding mental illness, or even the perception of mental illness, makes it next to impossible for the women to seek professional help.
Suicide by farmers makes up 3% of all suicides.


It is risk-free to think that there is the equivalent quantity of pillows in various selections offered today to the variety of individuals existing on the planet. Why should you after that select a Tommy Hilfiger wedge Pillow constructed from foam? Wedge pillows are terrific for boosting the high quality of rest, in addition to boosting several sorts of problems both physical in addition to clinical.
Foam is an excellent option because it shows extravagant living, along with offers outstanding assistance. There are various top qualities of foam to take care of. It is necessary to inspect the thickness of the foam that you purchase and also make certain that it has a memory element. Because it is your rest patterns that we are discussing, make certain you review tags thoroughly prior to you acquire your Pillow. Each brand name has a various suppleness, which you need to look for optimum complete satisfaction.
Millions are influenced with back and also neck discomfort. The factors might differ from bone condition to malformation of the skeletal structure. The cervix as well as a thoracic back boost with making use of this sort of wedge designed Pillow to provide tremendous alleviation. Avoid making use of ornamental and also low-cost toss pillows as these can harm the spinal column even more. Tommy Hilfiger wedge Pillow aids clients that require to rest at an angle of greater than thirty 5 levels to remove issues occurring from gastro-esophageal reflux and also hiatal rupture. This Pillow supplies the best angle for individuals with respiratory system trouble or injuries experienced in crashes.