package com.gyee.frame.model.auto;


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

public class InputoroutputspeedtotalExample {
    /**
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    protected String orderByClause;

    /**
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    protected boolean distinct;

    /**
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    protected List<Criteria> oredCriteria;

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public InputoroutputspeedtotalExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public String getOrderByClause() {
        return orderByClause;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public boolean isDistinct() {
        return distinct;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    /**
     * This class was generated by MyBatis Generator.
     * This class corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Integer value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("ID <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("ID in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("ID between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andWindturbineidIsNull() {
            addCriterion("WINDTURBINEID is null");
            return (Criteria) this;
        }

        public Criteria andWindturbineidIsNotNull() {
            addCriterion("WINDTURBINEID is not null");
            return (Criteria) this;
        }

        public Criteria andWindturbineidEqualTo(String value) {
            addCriterion("WINDTURBINEID =", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidNotEqualTo(String value) {
            addCriterion("WINDTURBINEID <>", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidGreaterThan(String value) {
            addCriterion("WINDTURBINEID >", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidGreaterThanOrEqualTo(String value) {
            addCriterion("WINDTURBINEID >=", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidLessThan(String value) {
            addCriterion("WINDTURBINEID <", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidLessThanOrEqualTo(String value) {
            addCriterion("WINDTURBINEID <=", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidLike(String value) {
            addCriterion("WINDTURBINEID like", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidNotLike(String value) {
            addCriterion("WINDTURBINEID not like", value, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidIn(List<String> values) {
            addCriterion("WINDTURBINEID in", values, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidNotIn(List<String> values) {
            addCriterion("WINDTURBINEID not in", values, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidBetween(String value1, String value2) {
            addCriterion("WINDTURBINEID between", value1, value2, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andWindturbineidNotBetween(String value1, String value2) {
            addCriterion("WINDTURBINEID not between", value1, value2, "windturbineid");
            return (Criteria) this;
        }

        public Criteria andRecorddateIsNull() {
            addCriterion("RECORDDATE is null");
            return (Criteria) this;
        }

        public Criteria andRecorddateIsNotNull() {
            addCriterion("RECORDDATE is not null");
            return (Criteria) this;
        }

        public Criteria andRecorddateEqualTo(Date value) {
            addCriterion("RECORDDATE =", value, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateNotEqualTo(Date value) {
            addCriterion("RECORDDATE <>", value, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateGreaterThan(Date value) {
            addCriterion("RECORDDATE >", value, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateGreaterThanOrEqualTo(Date value) {
            addCriterion("RECORDDATE >=", value, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateLessThan(Date value) {
            addCriterion("RECORDDATE <", value, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateLessThanOrEqualTo(Date value) {
            addCriterion("RECORDDATE <=", value, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateIn(List<Date> values) {
            addCriterion("RECORDDATE in", values, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateNotIn(List<Date> values) {
            addCriterion("RECORDDATE not in", values, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateBetween(Date value1, Date value2) {
            addCriterion("RECORDDATE between", value1, value2, "recorddate");
            return (Criteria) this;
        }

        public Criteria andRecorddateNotBetween(Date value1, Date value2) {
            addCriterion("RECORDDATE not between", value1, value2, "recorddate");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallIsNull() {
            addCriterion("DAYINPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallIsNotNull() {
            addCriterion("DAYINPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallEqualTo(Double value) {
            addCriterion("DAYINPUTSMALL =", value, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallNotEqualTo(Double value) {
            addCriterion("DAYINPUTSMALL <>", value, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallGreaterThan(Double value) {
            addCriterion("DAYINPUTSMALL >", value, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALL >=", value, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallLessThan(Double value) {
            addCriterion("DAYINPUTSMALL <", value, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALL <=", value, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallIn(List<Double> values) {
            addCriterion("DAYINPUTSMALL in", values, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallNotIn(List<Double> values) {
            addCriterion("DAYINPUTSMALL not in", values, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALL between", value1, value2, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALL not between", value1, value2, "dayinputsmall");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminIsNull() {
            addCriterion("DAYINPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminIsNotNull() {
            addCriterion("DAYINPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMIN =", value, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminNotEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMIN <>", value, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminGreaterThan(Double value) {
            addCriterion("DAYINPUTSMALLMIN >", value, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMIN >=", value, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminLessThan(Double value) {
            addCriterion("DAYINPUTSMALLMIN <", value, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMIN <=", value, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminIn(List<Double> values) {
            addCriterion("DAYINPUTSMALLMIN in", values, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminNotIn(List<Double> values) {
            addCriterion("DAYINPUTSMALLMIN not in", values, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALLMIN between", value1, value2, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALLMIN not between", value1, value2, "dayinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxIsNull() {
            addCriterion("DAYINPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxIsNotNull() {
            addCriterion("DAYINPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMAX =", value, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxNotEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMAX <>", value, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxGreaterThan(Double value) {
            addCriterion("DAYINPUTSMALLMAX >", value, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMAX >=", value, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxLessThan(Double value) {
            addCriterion("DAYINPUTSMALLMAX <", value, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLMAX <=", value, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxIn(List<Double> values) {
            addCriterion("DAYINPUTSMALLMAX in", values, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxNotIn(List<Double> values) {
            addCriterion("DAYINPUTSMALLMAX not in", values, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALLMAX between", value1, value2, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALLMAX not between", value1, value2, "dayinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigIsNull() {
            addCriterion("DAYINPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigIsNotNull() {
            addCriterion("DAYINPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigEqualTo(Double value) {
            addCriterion("DAYINPUTBIG =", value, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigNotEqualTo(Double value) {
            addCriterion("DAYINPUTBIG <>", value, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigGreaterThan(Double value) {
            addCriterion("DAYINPUTBIG >", value, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIG >=", value, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigLessThan(Double value) {
            addCriterion("DAYINPUTBIG <", value, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIG <=", value, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigIn(List<Double> values) {
            addCriterion("DAYINPUTBIG in", values, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigNotIn(List<Double> values) {
            addCriterion("DAYINPUTBIG not in", values, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIG between", value1, value2, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIG not between", value1, value2, "dayinputbig");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminIsNull() {
            addCriterion("DAYINPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminIsNotNull() {
            addCriterion("DAYINPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMIN =", value, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminNotEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMIN <>", value, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminGreaterThan(Double value) {
            addCriterion("DAYINPUTBIGMIN >", value, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMIN >=", value, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminLessThan(Double value) {
            addCriterion("DAYINPUTBIGMIN <", value, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMIN <=", value, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminIn(List<Double> values) {
            addCriterion("DAYINPUTBIGMIN in", values, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminNotIn(List<Double> values) {
            addCriterion("DAYINPUTBIGMIN not in", values, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIGMIN between", value1, value2, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigminNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIGMIN not between", value1, value2, "dayinputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxIsNull() {
            addCriterion("DAYINPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxIsNotNull() {
            addCriterion("DAYINPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMAX =", value, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxNotEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMAX <>", value, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxGreaterThan(Double value) {
            addCriterion("DAYINPUTBIGMAX >", value, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMAX >=", value, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxLessThan(Double value) {
            addCriterion("DAYINPUTBIGMAX <", value, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIGMAX <=", value, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxIn(List<Double> values) {
            addCriterion("DAYINPUTBIGMAX in", values, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxNotIn(List<Double> values) {
            addCriterion("DAYINPUTBIGMAX not in", values, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIGMAX between", value1, value2, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIGMAX not between", value1, value2, "dayinputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallIsNull() {
            addCriterion("DAYOUTPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallIsNotNull() {
            addCriterion("DAYOUTPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALL =", value, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALL <>", value, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallGreaterThan(Double value) {
            addCriterion("DAYOUTPUTSMALL >", value, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALL >=", value, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallLessThan(Double value) {
            addCriterion("DAYOUTPUTSMALL <", value, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALL <=", value, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALL in", values, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALL not in", values, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALL between", value1, value2, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALL not between", value1, value2, "dayoutputsmall");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminIsNull() {
            addCriterion("DAYOUTPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminIsNotNull() {
            addCriterion("DAYOUTPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMIN =", value, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMIN <>", value, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminGreaterThan(Double value) {
            addCriterion("DAYOUTPUTSMALLMIN >", value, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMIN >=", value, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminLessThan(Double value) {
            addCriterion("DAYOUTPUTSMALLMIN <", value, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMIN <=", value, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALLMIN in", values, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALLMIN not in", values, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALLMIN between", value1, value2, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALLMIN not between", value1, value2, "dayoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxIsNull() {
            addCriterion("DAYOUTPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxIsNotNull() {
            addCriterion("DAYOUTPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMAX =", value, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMAX <>", value, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxGreaterThan(Double value) {
            addCriterion("DAYOUTPUTSMALLMAX >", value, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMAX >=", value, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxLessThan(Double value) {
            addCriterion("DAYOUTPUTSMALLMAX <", value, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLMAX <=", value, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALLMAX in", values, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALLMAX not in", values, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALLMAX between", value1, value2, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALLMAX not between", value1, value2, "dayoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigIsNull() {
            addCriterion("DAYOUTPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigIsNotNull() {
            addCriterion("DAYOUTPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIG =", value, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIG <>", value, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigGreaterThan(Double value) {
            addCriterion("DAYOUTPUTBIG >", value, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIG >=", value, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigLessThan(Double value) {
            addCriterion("DAYOUTPUTBIG <", value, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIG <=", value, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIG in", values, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIG not in", values, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIG between", value1, value2, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIG not between", value1, value2, "dayoutputbig");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminIsNull() {
            addCriterion("DAYOUTPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminIsNotNull() {
            addCriterion("DAYOUTPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMIN =", value, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMIN <>", value, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminGreaterThan(Double value) {
            addCriterion("DAYOUTPUTBIGMIN >", value, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMIN >=", value, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminLessThan(Double value) {
            addCriterion("DAYOUTPUTBIGMIN <", value, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMIN <=", value, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIGMIN in", values, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIGMIN not in", values, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIGMIN between", value1, value2, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigminNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIGMIN not between", value1, value2, "dayoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxIsNull() {
            addCriterion("DAYOUTPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxIsNotNull() {
            addCriterion("DAYOUTPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMAX =", value, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMAX <>", value, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxGreaterThan(Double value) {
            addCriterion("DAYOUTPUTBIGMAX >", value, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMAX >=", value, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxLessThan(Double value) {
            addCriterion("DAYOUTPUTBIGMAX <", value, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGMAX <=", value, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIGMAX in", values, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIGMAX not in", values, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIGMAX between", value1, value2, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIGMAX not between", value1, value2, "dayoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallIsNull() {
            addCriterion("MONTHINPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallIsNotNull() {
            addCriterion("MONTHINPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALL =", value, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallNotEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALL <>", value, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallGreaterThan(Double value) {
            addCriterion("MONTHINPUTSMALL >", value, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALL >=", value, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallLessThan(Double value) {
            addCriterion("MONTHINPUTSMALL <", value, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALL <=", value, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALL in", values, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallNotIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALL not in", values, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALL between", value1, value2, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALL not between", value1, value2, "monthinputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminIsNull() {
            addCriterion("MONTHINPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminIsNotNull() {
            addCriterion("MONTHINPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMIN =", value, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminNotEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMIN <>", value, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminGreaterThan(Double value) {
            addCriterion("MONTHINPUTSMALLMIN >", value, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMIN >=", value, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminLessThan(Double value) {
            addCriterion("MONTHINPUTSMALLMIN <", value, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMIN <=", value, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALLMIN in", values, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminNotIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALLMIN not in", values, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALLMIN between", value1, value2, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALLMIN not between", value1, value2, "monthinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxIsNull() {
            addCriterion("MONTHINPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxIsNotNull() {
            addCriterion("MONTHINPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMAX =", value, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxNotEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMAX <>", value, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxGreaterThan(Double value) {
            addCriterion("MONTHINPUTSMALLMAX >", value, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMAX >=", value, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxLessThan(Double value) {
            addCriterion("MONTHINPUTSMALLMAX <", value, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLMAX <=", value, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALLMAX in", values, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxNotIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALLMAX not in", values, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALLMAX between", value1, value2, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALLMAX not between", value1, value2, "monthinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigIsNull() {
            addCriterion("MONTHINPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigIsNotNull() {
            addCriterion("MONTHINPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigEqualTo(Double value) {
            addCriterion("MONTHINPUTBIG =", value, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigNotEqualTo(Double value) {
            addCriterion("MONTHINPUTBIG <>", value, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigGreaterThan(Double value) {
            addCriterion("MONTHINPUTBIG >", value, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIG >=", value, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigLessThan(Double value) {
            addCriterion("MONTHINPUTBIG <", value, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIG <=", value, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigIn(List<Double> values) {
            addCriterion("MONTHINPUTBIG in", values, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigNotIn(List<Double> values) {
            addCriterion("MONTHINPUTBIG not in", values, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIG between", value1, value2, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIG not between", value1, value2, "monthinputbig");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminIsNull() {
            addCriterion("MONTHINPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminIsNotNull() {
            addCriterion("MONTHINPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMIN =", value, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminNotEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMIN <>", value, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminGreaterThan(Double value) {
            addCriterion("MONTHINPUTBIGMIN >", value, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMIN >=", value, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminLessThan(Double value) {
            addCriterion("MONTHINPUTBIGMIN <", value, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMIN <=", value, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminIn(List<Double> values) {
            addCriterion("MONTHINPUTBIGMIN in", values, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminNotIn(List<Double> values) {
            addCriterion("MONTHINPUTBIGMIN not in", values, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIGMIN between", value1, value2, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigminNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIGMIN not between", value1, value2, "monthinputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxIsNull() {
            addCriterion("MONTHINPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxIsNotNull() {
            addCriterion("MONTHINPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMAX =", value, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxNotEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMAX <>", value, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxGreaterThan(Double value) {
            addCriterion("MONTHINPUTBIGMAX >", value, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMAX >=", value, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxLessThan(Double value) {
            addCriterion("MONTHINPUTBIGMAX <", value, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGMAX <=", value, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxIn(List<Double> values) {
            addCriterion("MONTHINPUTBIGMAX in", values, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxNotIn(List<Double> values) {
            addCriterion("MONTHINPUTBIGMAX not in", values, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIGMAX between", value1, value2, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIGMAX not between", value1, value2, "monthinputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallIsNull() {
            addCriterion("MONTHOUTPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallIsNotNull() {
            addCriterion("MONTHOUTPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALL =", value, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALL <>", value, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTSMALL >", value, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALL >=", value, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallLessThan(Double value) {
            addCriterion("MONTHOUTPUTSMALL <", value, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALL <=", value, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALL in", values, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALL not in", values, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALL between", value1, value2, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALL not between", value1, value2, "monthoutputsmall");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminIsNull() {
            addCriterion("MONTHOUTPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminIsNotNull() {
            addCriterion("MONTHOUTPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMIN =", value, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMIN <>", value, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTSMALLMIN >", value, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMIN >=", value, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminLessThan(Double value) {
            addCriterion("MONTHOUTPUTSMALLMIN <", value, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMIN <=", value, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALLMIN in", values, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALLMIN not in", values, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALLMIN between", value1, value2, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALLMIN not between", value1, value2, "monthoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxIsNull() {
            addCriterion("MONTHOUTPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxIsNotNull() {
            addCriterion("MONTHOUTPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMAX =", value, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMAX <>", value, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTSMALLMAX >", value, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMAX >=", value, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxLessThan(Double value) {
            addCriterion("MONTHOUTPUTSMALLMAX <", value, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLMAX <=", value, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALLMAX in", values, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALLMAX not in", values, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALLMAX between", value1, value2, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALLMAX not between", value1, value2, "monthoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigIsNull() {
            addCriterion("MONTHOUTPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigIsNotNull() {
            addCriterion("MONTHOUTPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIG =", value, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIG <>", value, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTBIG >", value, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIG >=", value, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigLessThan(Double value) {
            addCriterion("MONTHOUTPUTBIG <", value, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIG <=", value, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIG in", values, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIG not in", values, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIG between", value1, value2, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIG not between", value1, value2, "monthoutputbig");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminIsNull() {
            addCriterion("MONTHOUTPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminIsNotNull() {
            addCriterion("MONTHOUTPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMIN =", value, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMIN <>", value, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTBIGMIN >", value, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMIN >=", value, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminLessThan(Double value) {
            addCriterion("MONTHOUTPUTBIGMIN <", value, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMIN <=", value, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIGMIN in", values, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIGMIN not in", values, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIGMIN between", value1, value2, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigminNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIGMIN not between", value1, value2, "monthoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxIsNull() {
            addCriterion("MONTHOUTPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxIsNotNull() {
            addCriterion("MONTHOUTPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMAX =", value, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMAX <>", value, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTBIGMAX >", value, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMAX >=", value, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxLessThan(Double value) {
            addCriterion("MONTHOUTPUTBIGMAX <", value, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGMAX <=", value, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIGMAX in", values, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIGMAX not in", values, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIGMAX between", value1, value2, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIGMAX not between", value1, value2, "monthoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallIsNull() {
            addCriterion("YEARINPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallIsNotNull() {
            addCriterion("YEARINPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallEqualTo(Double value) {
            addCriterion("YEARINPUTSMALL =", value, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallNotEqualTo(Double value) {
            addCriterion("YEARINPUTSMALL <>", value, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallGreaterThan(Double value) {
            addCriterion("YEARINPUTSMALL >", value, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALL >=", value, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallLessThan(Double value) {
            addCriterion("YEARINPUTSMALL <", value, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALL <=", value, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallIn(List<Double> values) {
            addCriterion("YEARINPUTSMALL in", values, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallNotIn(List<Double> values) {
            addCriterion("YEARINPUTSMALL not in", values, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALL between", value1, value2, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALL not between", value1, value2, "yearinputsmall");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminIsNull() {
            addCriterion("YEARINPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminIsNotNull() {
            addCriterion("YEARINPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMIN =", value, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminNotEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMIN <>", value, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminGreaterThan(Double value) {
            addCriterion("YEARINPUTSMALLMIN >", value, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMIN >=", value, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminLessThan(Double value) {
            addCriterion("YEARINPUTSMALLMIN <", value, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMIN <=", value, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminIn(List<Double> values) {
            addCriterion("YEARINPUTSMALLMIN in", values, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminNotIn(List<Double> values) {
            addCriterion("YEARINPUTSMALLMIN not in", values, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALLMIN between", value1, value2, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALLMIN not between", value1, value2, "yearinputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxIsNull() {
            addCriterion("YEARINPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxIsNotNull() {
            addCriterion("YEARINPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMAX =", value, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxNotEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMAX <>", value, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxGreaterThan(Double value) {
            addCriterion("YEARINPUTSMALLMAX >", value, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMAX >=", value, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxLessThan(Double value) {
            addCriterion("YEARINPUTSMALLMAX <", value, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLMAX <=", value, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxIn(List<Double> values) {
            addCriterion("YEARINPUTSMALLMAX in", values, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxNotIn(List<Double> values) {
            addCriterion("YEARINPUTSMALLMAX not in", values, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALLMAX between", value1, value2, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALLMAX not between", value1, value2, "yearinputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigIsNull() {
            addCriterion("YEARINPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigIsNotNull() {
            addCriterion("YEARINPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigEqualTo(Double value) {
            addCriterion("YEARINPUTBIG =", value, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigNotEqualTo(Double value) {
            addCriterion("YEARINPUTBIG <>", value, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigGreaterThan(Double value) {
            addCriterion("YEARINPUTBIG >", value, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIG >=", value, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigLessThan(Double value) {
            addCriterion("YEARINPUTBIG <", value, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIG <=", value, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigIn(List<Double> values) {
            addCriterion("YEARINPUTBIG in", values, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigNotIn(List<Double> values) {
            addCriterion("YEARINPUTBIG not in", values, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIG between", value1, value2, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIG not between", value1, value2, "yearinputbig");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminIsNull() {
            addCriterion("YEARINPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminIsNotNull() {
            addCriterion("YEARINPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMIN =", value, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminNotEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMIN <>", value, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminGreaterThan(Double value) {
            addCriterion("YEARINPUTBIGMIN >", value, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMIN >=", value, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminLessThan(Double value) {
            addCriterion("YEARINPUTBIGMIN <", value, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMIN <=", value, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminIn(List<Double> values) {
            addCriterion("YEARINPUTBIGMIN in", values, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminNotIn(List<Double> values) {
            addCriterion("YEARINPUTBIGMIN not in", values, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIGMIN between", value1, value2, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigminNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIGMIN not between", value1, value2, "yearinputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxIsNull() {
            addCriterion("YEARINPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxIsNotNull() {
            addCriterion("YEARINPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMAX =", value, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxNotEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMAX <>", value, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxGreaterThan(Double value) {
            addCriterion("YEARINPUTBIGMAX >", value, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMAX >=", value, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxLessThan(Double value) {
            addCriterion("YEARINPUTBIGMAX <", value, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIGMAX <=", value, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxIn(List<Double> values) {
            addCriterion("YEARINPUTBIGMAX in", values, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxNotIn(List<Double> values) {
            addCriterion("YEARINPUTBIGMAX not in", values, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIGMAX between", value1, value2, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearinputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIGMAX not between", value1, value2, "yearinputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallIsNull() {
            addCriterion("YEAROUTPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallIsNotNull() {
            addCriterion("YEAROUTPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALL =", value, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALL <>", value, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallGreaterThan(Double value) {
            addCriterion("YEAROUTPUTSMALL >", value, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALL >=", value, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallLessThan(Double value) {
            addCriterion("YEAROUTPUTSMALL <", value, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALL <=", value, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALL in", values, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALL not in", values, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALL between", value1, value2, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALL not between", value1, value2, "yearoutputsmall");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminIsNull() {
            addCriterion("YEAROUTPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminIsNotNull() {
            addCriterion("YEAROUTPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMIN =", value, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMIN <>", value, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminGreaterThan(Double value) {
            addCriterion("YEAROUTPUTSMALLMIN >", value, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMIN >=", value, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminLessThan(Double value) {
            addCriterion("YEAROUTPUTSMALLMIN <", value, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMIN <=", value, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALLMIN in", values, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALLMIN not in", values, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALLMIN between", value1, value2, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALLMIN not between", value1, value2, "yearoutputsmallmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxIsNull() {
            addCriterion("YEAROUTPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxIsNotNull() {
            addCriterion("YEAROUTPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMAX =", value, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMAX <>", value, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxGreaterThan(Double value) {
            addCriterion("YEAROUTPUTSMALLMAX >", value, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMAX >=", value, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxLessThan(Double value) {
            addCriterion("YEAROUTPUTSMALLMAX <", value, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLMAX <=", value, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALLMAX in", values, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALLMAX not in", values, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALLMAX between", value1, value2, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALLMAX not between", value1, value2, "yearoutputsmallmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigIsNull() {
            addCriterion("YEAROUTPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigIsNotNull() {
            addCriterion("YEAROUTPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIG =", value, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIG <>", value, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigGreaterThan(Double value) {
            addCriterion("YEAROUTPUTBIG >", value, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIG >=", value, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigLessThan(Double value) {
            addCriterion("YEAROUTPUTBIG <", value, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIG <=", value, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIG in", values, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIG not in", values, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIG between", value1, value2, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIG not between", value1, value2, "yearoutputbig");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminIsNull() {
            addCriterion("YEAROUTPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminIsNotNull() {
            addCriterion("YEAROUTPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMIN =", value, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMIN <>", value, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminGreaterThan(Double value) {
            addCriterion("YEAROUTPUTBIGMIN >", value, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMIN >=", value, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminLessThan(Double value) {
            addCriterion("YEAROUTPUTBIGMIN <", value, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMIN <=", value, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIGMIN in", values, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIGMIN not in", values, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIGMIN between", value1, value2, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigminNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIGMIN not between", value1, value2, "yearoutputbigmin");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxIsNull() {
            addCriterion("YEAROUTPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxIsNotNull() {
            addCriterion("YEAROUTPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMAX =", value, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMAX <>", value, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxGreaterThan(Double value) {
            addCriterion("YEAROUTPUTBIGMAX >", value, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMAX >=", value, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxLessThan(Double value) {
            addCriterion("YEAROUTPUTBIGMAX <", value, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGMAX <=", value, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIGMAX in", values, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIGMAX not in", values, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIGMAX between", value1, value2, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIGMAX not between", value1, value2, "yearoutputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallIsNull() {
            addCriterion("INPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andInputsmallIsNotNull() {
            addCriterion("INPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andInputsmallEqualTo(Double value) {
            addCriterion("INPUTSMALL =", value, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallNotEqualTo(Double value) {
            addCriterion("INPUTSMALL <>", value, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallGreaterThan(Double value) {
            addCriterion("INPUTSMALL >", value, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALL >=", value, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallLessThan(Double value) {
            addCriterion("INPUTSMALL <", value, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallLessThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALL <=", value, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallIn(List<Double> values) {
            addCriterion("INPUTSMALL in", values, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallNotIn(List<Double> values) {
            addCriterion("INPUTSMALL not in", values, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALL between", value1, value2, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallNotBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALL not between", value1, value2, "inputsmall");
            return (Criteria) this;
        }

        public Criteria andInputsmallminIsNull() {
            addCriterion("INPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andInputsmallminIsNotNull() {
            addCriterion("INPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andInputsmallminEqualTo(Double value) {
            addCriterion("INPUTSMALLMIN =", value, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminNotEqualTo(Double value) {
            addCriterion("INPUTSMALLMIN <>", value, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminGreaterThan(Double value) {
            addCriterion("INPUTSMALLMIN >", value, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALLMIN >=", value, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminLessThan(Double value) {
            addCriterion("INPUTSMALLMIN <", value, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALLMIN <=", value, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminIn(List<Double> values) {
            addCriterion("INPUTSMALLMIN in", values, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminNotIn(List<Double> values) {
            addCriterion("INPUTSMALLMIN not in", values, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALLMIN between", value1, value2, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALLMIN not between", value1, value2, "inputsmallmin");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxIsNull() {
            addCriterion("INPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxIsNotNull() {
            addCriterion("INPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxEqualTo(Double value) {
            addCriterion("INPUTSMALLMAX =", value, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxNotEqualTo(Double value) {
            addCriterion("INPUTSMALLMAX <>", value, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxGreaterThan(Double value) {
            addCriterion("INPUTSMALLMAX >", value, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALLMAX >=", value, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxLessThan(Double value) {
            addCriterion("INPUTSMALLMAX <", value, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALLMAX <=", value, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxIn(List<Double> values) {
            addCriterion("INPUTSMALLMAX in", values, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxNotIn(List<Double> values) {
            addCriterion("INPUTSMALLMAX not in", values, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALLMAX between", value1, value2, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALLMAX not between", value1, value2, "inputsmallmax");
            return (Criteria) this;
        }

        public Criteria andInputbigIsNull() {
            addCriterion("INPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andInputbigIsNotNull() {
            addCriterion("INPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andInputbigEqualTo(Double value) {
            addCriterion("INPUTBIG =", value, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigNotEqualTo(Double value) {
            addCriterion("INPUTBIG <>", value, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigGreaterThan(Double value) {
            addCriterion("INPUTBIG >", value, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTBIG >=", value, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigLessThan(Double value) {
            addCriterion("INPUTBIG <", value, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigLessThanOrEqualTo(Double value) {
            addCriterion("INPUTBIG <=", value, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigIn(List<Double> values) {
            addCriterion("INPUTBIG in", values, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigNotIn(List<Double> values) {
            addCriterion("INPUTBIG not in", values, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigBetween(Double value1, Double value2) {
            addCriterion("INPUTBIG between", value1, value2, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigNotBetween(Double value1, Double value2) {
            addCriterion("INPUTBIG not between", value1, value2, "inputbig");
            return (Criteria) this;
        }

        public Criteria andInputbigminIsNull() {
            addCriterion("INPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andInputbigminIsNotNull() {
            addCriterion("INPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andInputbigminEqualTo(Double value) {
            addCriterion("INPUTBIGMIN =", value, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminNotEqualTo(Double value) {
            addCriterion("INPUTBIGMIN <>", value, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminGreaterThan(Double value) {
            addCriterion("INPUTBIGMIN >", value, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTBIGMIN >=", value, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminLessThan(Double value) {
            addCriterion("INPUTBIGMIN <", value, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminLessThanOrEqualTo(Double value) {
            addCriterion("INPUTBIGMIN <=", value, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminIn(List<Double> values) {
            addCriterion("INPUTBIGMIN in", values, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminNotIn(List<Double> values) {
            addCriterion("INPUTBIGMIN not in", values, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminBetween(Double value1, Double value2) {
            addCriterion("INPUTBIGMIN between", value1, value2, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigminNotBetween(Double value1, Double value2) {
            addCriterion("INPUTBIGMIN not between", value1, value2, "inputbigmin");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxIsNull() {
            addCriterion("INPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxIsNotNull() {
            addCriterion("INPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxEqualTo(Double value) {
            addCriterion("INPUTBIGMAX =", value, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxNotEqualTo(Double value) {
            addCriterion("INPUTBIGMAX <>", value, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxGreaterThan(Double value) {
            addCriterion("INPUTBIGMAX >", value, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTBIGMAX >=", value, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxLessThan(Double value) {
            addCriterion("INPUTBIGMAX <", value, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("INPUTBIGMAX <=", value, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxIn(List<Double> values) {
            addCriterion("INPUTBIGMAX in", values, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxNotIn(List<Double> values) {
            addCriterion("INPUTBIGMAX not in", values, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxBetween(Double value1, Double value2) {
            addCriterion("INPUTBIGMAX between", value1, value2, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andInputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("INPUTBIGMAX not between", value1, value2, "inputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallIsNull() {
            addCriterion("OUTPUTSMALL is null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallIsNotNull() {
            addCriterion("OUTPUTSMALL is not null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallEqualTo(Double value) {
            addCriterion("OUTPUTSMALL =", value, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallNotEqualTo(Double value) {
            addCriterion("OUTPUTSMALL <>", value, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallGreaterThan(Double value) {
            addCriterion("OUTPUTSMALL >", value, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALL >=", value, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallLessThan(Double value) {
            addCriterion("OUTPUTSMALL <", value, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALL <=", value, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallIn(List<Double> values) {
            addCriterion("OUTPUTSMALL in", values, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallNotIn(List<Double> values) {
            addCriterion("OUTPUTSMALL not in", values, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALL between", value1, value2, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALL not between", value1, value2, "outputsmall");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminIsNull() {
            addCriterion("OUTPUTSMALLMIN is null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminIsNotNull() {
            addCriterion("OUTPUTSMALLMIN is not null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMIN =", value, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminNotEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMIN <>", value, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminGreaterThan(Double value) {
            addCriterion("OUTPUTSMALLMIN >", value, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMIN >=", value, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminLessThan(Double value) {
            addCriterion("OUTPUTSMALLMIN <", value, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMIN <=", value, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminIn(List<Double> values) {
            addCriterion("OUTPUTSMALLMIN in", values, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminNotIn(List<Double> values) {
            addCriterion("OUTPUTSMALLMIN not in", values, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALLMIN between", value1, value2, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallminNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALLMIN not between", value1, value2, "outputsmallmin");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxIsNull() {
            addCriterion("OUTPUTSMALLMAX is null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxIsNotNull() {
            addCriterion("OUTPUTSMALLMAX is not null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMAX =", value, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxNotEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMAX <>", value, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxGreaterThan(Double value) {
            addCriterion("OUTPUTSMALLMAX >", value, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMAX >=", value, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxLessThan(Double value) {
            addCriterion("OUTPUTSMALLMAX <", value, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALLMAX <=", value, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxIn(List<Double> values) {
            addCriterion("OUTPUTSMALLMAX in", values, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxNotIn(List<Double> values) {
            addCriterion("OUTPUTSMALLMAX not in", values, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALLMAX between", value1, value2, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputsmallmaxNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALLMAX not between", value1, value2, "outputsmallmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigIsNull() {
            addCriterion("OUTPUTBIG is null");
            return (Criteria) this;
        }

        public Criteria andOutputbigIsNotNull() {
            addCriterion("OUTPUTBIG is not null");
            return (Criteria) this;
        }

        public Criteria andOutputbigEqualTo(Double value) {
            addCriterion("OUTPUTBIG =", value, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigNotEqualTo(Double value) {
            addCriterion("OUTPUTBIG <>", value, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigGreaterThan(Double value) {
            addCriterion("OUTPUTBIG >", value, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIG >=", value, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigLessThan(Double value) {
            addCriterion("OUTPUTBIG <", value, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIG <=", value, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigIn(List<Double> values) {
            addCriterion("OUTPUTBIG in", values, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigNotIn(List<Double> values) {
            addCriterion("OUTPUTBIG not in", values, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIG between", value1, value2, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIG not between", value1, value2, "outputbig");
            return (Criteria) this;
        }

        public Criteria andOutputbigminIsNull() {
            addCriterion("OUTPUTBIGMIN is null");
            return (Criteria) this;
        }

        public Criteria andOutputbigminIsNotNull() {
            addCriterion("OUTPUTBIGMIN is not null");
            return (Criteria) this;
        }

        public Criteria andOutputbigminEqualTo(Double value) {
            addCriterion("OUTPUTBIGMIN =", value, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminNotEqualTo(Double value) {
            addCriterion("OUTPUTBIGMIN <>", value, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminGreaterThan(Double value) {
            addCriterion("OUTPUTBIGMIN >", value, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIGMIN >=", value, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminLessThan(Double value) {
            addCriterion("OUTPUTBIGMIN <", value, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIGMIN <=", value, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminIn(List<Double> values) {
            addCriterion("OUTPUTBIGMIN in", values, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminNotIn(List<Double> values) {
            addCriterion("OUTPUTBIGMIN not in", values, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIGMIN between", value1, value2, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigminNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIGMIN not between", value1, value2, "outputbigmin");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxIsNull() {
            addCriterion("OUTPUTBIGMAX is null");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxIsNotNull() {
            addCriterion("OUTPUTBIGMAX is not null");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAX =", value, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxNotEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAX <>", value, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxGreaterThan(Double value) {
            addCriterion("OUTPUTBIGMAX >", value, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAX >=", value, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxLessThan(Double value) {
            addCriterion("OUTPUTBIGMAX <", value, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAX <=", value, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxIn(List<Double> values) {
            addCriterion("OUTPUTBIGMAX in", values, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxNotIn(List<Double> values) {
            addCriterion("OUTPUTBIGMAX not in", values, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIGMAX between", value1, value2, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIGMAX not between", value1, value2, "outputbigmax");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioIsNull() {
            addCriterion("DAYINPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioIsNotNull() {
            addCriterion("DAYINPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLRATIO =", value, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioNotEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLRATIO <>", value, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioGreaterThan(Double value) {
            addCriterion("DAYINPUTSMALLRATIO >", value, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLRATIO >=", value, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioLessThan(Double value) {
            addCriterion("DAYINPUTSMALLRATIO <", value, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTSMALLRATIO <=", value, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioIn(List<Double> values) {
            addCriterion("DAYINPUTSMALLRATIO in", values, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioNotIn(List<Double> values) {
            addCriterion("DAYINPUTSMALLRATIO not in", values, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALLRATIO between", value1, value2, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTSMALLRATIO not between", value1, value2, "dayinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioIsNull() {
            addCriterion("DAYOUTPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioIsNotNull() {
            addCriterion("DAYOUTPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLRATIO =", value, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLRATIO <>", value, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioGreaterThan(Double value) {
            addCriterion("DAYOUTPUTSMALLRATIO >", value, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLRATIO >=", value, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioLessThan(Double value) {
            addCriterion("DAYOUTPUTSMALLRATIO <", value, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTSMALLRATIO <=", value, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALLRATIO in", values, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTSMALLRATIO not in", values, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALLRATIO between", value1, value2, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTSMALLRATIO not between", value1, value2, "dayoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioIsNull() {
            addCriterion("DAYINPUTBIGRATIO is null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioIsNotNull() {
            addCriterion("DAYINPUTBIGRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioEqualTo(Double value) {
            addCriterion("DAYINPUTBIGRATIO =", value, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioNotEqualTo(Double value) {
            addCriterion("DAYINPUTBIGRATIO <>", value, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioGreaterThan(Double value) {
            addCriterion("DAYINPUTBIGRATIO >", value, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIGRATIO >=", value, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioLessThan(Double value) {
            addCriterion("DAYINPUTBIGRATIO <", value, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioLessThanOrEqualTo(Double value) {
            addCriterion("DAYINPUTBIGRATIO <=", value, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioIn(List<Double> values) {
            addCriterion("DAYINPUTBIGRATIO in", values, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioNotIn(List<Double> values) {
            addCriterion("DAYINPUTBIGRATIO not in", values, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIGRATIO between", value1, value2, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayinputbigratioNotBetween(Double value1, Double value2) {
            addCriterion("DAYINPUTBIGRATIO not between", value1, value2, "dayinputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioIsNull() {
            addCriterion("DAYOUTPUTBIGRATIO is null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioIsNotNull() {
            addCriterion("DAYOUTPUTBIGRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGRATIO =", value, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioNotEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGRATIO <>", value, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioGreaterThan(Double value) {
            addCriterion("DAYOUTPUTBIGRATIO >", value, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioGreaterThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGRATIO >=", value, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioLessThan(Double value) {
            addCriterion("DAYOUTPUTBIGRATIO <", value, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioLessThanOrEqualTo(Double value) {
            addCriterion("DAYOUTPUTBIGRATIO <=", value, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIGRATIO in", values, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioNotIn(List<Double> values) {
            addCriterion("DAYOUTPUTBIGRATIO not in", values, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIGRATIO between", value1, value2, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andDayoutputbigratioNotBetween(Double value1, Double value2) {
            addCriterion("DAYOUTPUTBIGRATIO not between", value1, value2, "dayoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioIsNull() {
            addCriterion("MONTHINPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioIsNotNull() {
            addCriterion("MONTHINPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLRATIO =", value, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioNotEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLRATIO <>", value, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioGreaterThan(Double value) {
            addCriterion("MONTHINPUTSMALLRATIO >", value, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLRATIO >=", value, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioLessThan(Double value) {
            addCriterion("MONTHINPUTSMALLRATIO <", value, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTSMALLRATIO <=", value, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALLRATIO in", values, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioNotIn(List<Double> values) {
            addCriterion("MONTHINPUTSMALLRATIO not in", values, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALLRATIO between", value1, value2, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTSMALLRATIO not between", value1, value2, "monthinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioIsNull() {
            addCriterion("MONTHOUTPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioIsNotNull() {
            addCriterion("MONTHOUTPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLRATIO =", value, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLRATIO <>", value, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTSMALLRATIO >", value, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLRATIO >=", value, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioLessThan(Double value) {
            addCriterion("MONTHOUTPUTSMALLRATIO <", value, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTSMALLRATIO <=", value, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALLRATIO in", values, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTSMALLRATIO not in", values, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALLRATIO between", value1, value2, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTSMALLRATIO not between", value1, value2, "monthoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioIsNull() {
            addCriterion("MONTHINPUTBIGRATIO is null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioIsNotNull() {
            addCriterion("MONTHINPUTBIGRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGRATIO =", value, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioNotEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGRATIO <>", value, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioGreaterThan(Double value) {
            addCriterion("MONTHINPUTBIGRATIO >", value, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGRATIO >=", value, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioLessThan(Double value) {
            addCriterion("MONTHINPUTBIGRATIO <", value, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioLessThanOrEqualTo(Double value) {
            addCriterion("MONTHINPUTBIGRATIO <=", value, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioIn(List<Double> values) {
            addCriterion("MONTHINPUTBIGRATIO in", values, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioNotIn(List<Double> values) {
            addCriterion("MONTHINPUTBIGRATIO not in", values, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIGRATIO between", value1, value2, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthinputbigratioNotBetween(Double value1, Double value2) {
            addCriterion("MONTHINPUTBIGRATIO not between", value1, value2, "monthinputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioIsNull() {
            addCriterion("MONTHOUTPUTBIGRATIO is null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioIsNotNull() {
            addCriterion("MONTHOUTPUTBIGRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGRATIO =", value, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioNotEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGRATIO <>", value, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioGreaterThan(Double value) {
            addCriterion("MONTHOUTPUTBIGRATIO >", value, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioGreaterThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGRATIO >=", value, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioLessThan(Double value) {
            addCriterion("MONTHOUTPUTBIGRATIO <", value, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioLessThanOrEqualTo(Double value) {
            addCriterion("MONTHOUTPUTBIGRATIO <=", value, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIGRATIO in", values, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioNotIn(List<Double> values) {
            addCriterion("MONTHOUTPUTBIGRATIO not in", values, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIGRATIO between", value1, value2, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andMonthoutputbigratioNotBetween(Double value1, Double value2) {
            addCriterion("MONTHOUTPUTBIGRATIO not between", value1, value2, "monthoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioIsNull() {
            addCriterion("YEARINPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioIsNotNull() {
            addCriterion("YEARINPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLRATIO =", value, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioNotEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLRATIO <>", value, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioGreaterThan(Double value) {
            addCriterion("YEARINPUTSMALLRATIO >", value, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLRATIO >=", value, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioLessThan(Double value) {
            addCriterion("YEARINPUTSMALLRATIO <", value, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTSMALLRATIO <=", value, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioIn(List<Double> values) {
            addCriterion("YEARINPUTSMALLRATIO in", values, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioNotIn(List<Double> values) {
            addCriterion("YEARINPUTSMALLRATIO not in", values, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALLRATIO between", value1, value2, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTSMALLRATIO not between", value1, value2, "yearinputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioIsNull() {
            addCriterion("YEAROUTPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioIsNotNull() {
            addCriterion("YEAROUTPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLRATIO =", value, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLRATIO <>", value, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioGreaterThan(Double value) {
            addCriterion("YEAROUTPUTSMALLRATIO >", value, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLRATIO >=", value, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioLessThan(Double value) {
            addCriterion("YEAROUTPUTSMALLRATIO <", value, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTSMALLRATIO <=", value, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALLRATIO in", values, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTSMALLRATIO not in", values, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALLRATIO between", value1, value2, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTSMALLRATIO not between", value1, value2, "yearoutputsmallratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioIsNull() {
            addCriterion("YEARINPUTBIGRATIO is null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioIsNotNull() {
            addCriterion("YEARINPUTBIGRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioEqualTo(Double value) {
            addCriterion("YEARINPUTBIGRATIO =", value, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioNotEqualTo(Double value) {
            addCriterion("YEARINPUTBIGRATIO <>", value, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioGreaterThan(Double value) {
            addCriterion("YEARINPUTBIGRATIO >", value, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioGreaterThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIGRATIO >=", value, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioLessThan(Double value) {
            addCriterion("YEARINPUTBIGRATIO <", value, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioLessThanOrEqualTo(Double value) {
            addCriterion("YEARINPUTBIGRATIO <=", value, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioIn(List<Double> values) {
            addCriterion("YEARINPUTBIGRATIO in", values, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioNotIn(List<Double> values) {
            addCriterion("YEARINPUTBIGRATIO not in", values, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIGRATIO between", value1, value2, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearinputbigratioNotBetween(Double value1, Double value2) {
            addCriterion("YEARINPUTBIGRATIO not between", value1, value2, "yearinputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioIsNull() {
            addCriterion("YEAROUTPUTBIGRATIO is null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioIsNotNull() {
            addCriterion("YEAROUTPUTBIGRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGRATIO =", value, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioNotEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGRATIO <>", value, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioGreaterThan(Double value) {
            addCriterion("YEAROUTPUTBIGRATIO >", value, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioGreaterThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGRATIO >=", value, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioLessThan(Double value) {
            addCriterion("YEAROUTPUTBIGRATIO <", value, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioLessThanOrEqualTo(Double value) {
            addCriterion("YEAROUTPUTBIGRATIO <=", value, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIGRATIO in", values, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioNotIn(List<Double> values) {
            addCriterion("YEAROUTPUTBIGRATIO not in", values, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIGRATIO between", value1, value2, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andYearoutputbigratioNotBetween(Double value1, Double value2) {
            addCriterion("YEAROUTPUTBIGRATIO not between", value1, value2, "yearoutputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioIsNull() {
            addCriterion("INPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioIsNotNull() {
            addCriterion("INPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioEqualTo(Double value) {
            addCriterion("INPUTSMALLRATIO =", value, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioNotEqualTo(Double value) {
            addCriterion("INPUTSMALLRATIO <>", value, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioGreaterThan(Double value) {
            addCriterion("INPUTSMALLRATIO >", value, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALLRATIO >=", value, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioLessThan(Double value) {
            addCriterion("INPUTSMALLRATIO <", value, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("INPUTSMALLRATIO <=", value, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioIn(List<Double> values) {
            addCriterion("INPUTSMALLRATIO in", values, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioNotIn(List<Double> values) {
            addCriterion("INPUTSMALLRATIO not in", values, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALLRATIO between", value1, value2, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("INPUTSMALLRATIO not between", value1, value2, "inputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioIsNull() {
            addCriterion("OUTPUTSMALLRATIO is null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioIsNotNull() {
            addCriterion("OUTPUTSMALLRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioEqualTo(Double value) {
            addCriterion("OUTPUTSMALLRATIO =", value, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioNotEqualTo(Double value) {
            addCriterion("OUTPUTSMALLRATIO <>", value, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioGreaterThan(Double value) {
            addCriterion("OUTPUTSMALLRATIO >", value, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALLRATIO >=", value, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioLessThan(Double value) {
            addCriterion("OUTPUTSMALLRATIO <", value, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTSMALLRATIO <=", value, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioIn(List<Double> values) {
            addCriterion("OUTPUTSMALLRATIO in", values, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioNotIn(List<Double> values) {
            addCriterion("OUTPUTSMALLRATIO not in", values, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALLRATIO between", value1, value2, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andOutputsmallratioNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTSMALLRATIO not between", value1, value2, "outputsmallratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioIsNull() {
            addCriterion("INPUTBIGRATIO is null");
            return (Criteria) this;
        }

        public Criteria andInputbigratioIsNotNull() {
            addCriterion("INPUTBIGRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andInputbigratioEqualTo(Double value) {
            addCriterion("INPUTBIGRATIO =", value, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioNotEqualTo(Double value) {
            addCriterion("INPUTBIGRATIO <>", value, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioGreaterThan(Double value) {
            addCriterion("INPUTBIGRATIO >", value, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioGreaterThanOrEqualTo(Double value) {
            addCriterion("INPUTBIGRATIO >=", value, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioLessThan(Double value) {
            addCriterion("INPUTBIGRATIO <", value, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioLessThanOrEqualTo(Double value) {
            addCriterion("INPUTBIGRATIO <=", value, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioIn(List<Double> values) {
            addCriterion("INPUTBIGRATIO in", values, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioNotIn(List<Double> values) {
            addCriterion("INPUTBIGRATIO not in", values, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioBetween(Double value1, Double value2) {
            addCriterion("INPUTBIGRATIO between", value1, value2, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andInputbigratioNotBetween(Double value1, Double value2) {
            addCriterion("INPUTBIGRATIO not between", value1, value2, "inputbigratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioIsNull() {
            addCriterion("OUTPUTBIGMAXRATIO is null");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioIsNotNull() {
            addCriterion("OUTPUTBIGMAXRATIO is not null");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAXRATIO =", value, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioNotEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAXRATIO <>", value, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioGreaterThan(Double value) {
            addCriterion("OUTPUTBIGMAXRATIO >", value, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioGreaterThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAXRATIO >=", value, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioLessThan(Double value) {
            addCriterion("OUTPUTBIGMAXRATIO <", value, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioLessThanOrEqualTo(Double value) {
            addCriterion("OUTPUTBIGMAXRATIO <=", value, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioIn(List<Double> values) {
            addCriterion("OUTPUTBIGMAXRATIO in", values, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioNotIn(List<Double> values) {
            addCriterion("OUTPUTBIGMAXRATIO not in", values, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIGMAXRATIO between", value1, value2, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andOutputbigmaxratioNotBetween(Double value1, Double value2) {
            addCriterion("OUTPUTBIGMAXRATIO not between", value1, value2, "outputbigmaxratio");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidIsNull() {
            addCriterion("WINDPOWERSTATIONID is null");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidIsNotNull() {
            addCriterion("WINDPOWERSTATIONID is not null");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidEqualTo(String value) {
            addCriterion("WINDPOWERSTATIONID =", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidNotEqualTo(String value) {
            addCriterion("WINDPOWERSTATIONID <>", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidGreaterThan(String value) {
            addCriterion("WINDPOWERSTATIONID >", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidGreaterThanOrEqualTo(String value) {
            addCriterion("WINDPOWERSTATIONID >=", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidLessThan(String value) {
            addCriterion("WINDPOWERSTATIONID <", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidLessThanOrEqualTo(String value) {
            addCriterion("WINDPOWERSTATIONID <=", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidLike(String value) {
            addCriterion("WINDPOWERSTATIONID like", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidNotLike(String value) {
            addCriterion("WINDPOWERSTATIONID not like", value, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidIn(List<String> values) {
            addCriterion("WINDPOWERSTATIONID in", values, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidNotIn(List<String> values) {
            addCriterion("WINDPOWERSTATIONID not in", values, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidBetween(String value1, String value2) {
            addCriterion("WINDPOWERSTATIONID between", value1, value2, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andWindpowerstationidNotBetween(String value1, String value2) {
            addCriterion("WINDPOWERSTATIONID not between", value1, value2, "windpowerstationid");
            return (Criteria) this;
        }

        public Criteria andProjectidIsNull() {
            addCriterion("PROJECTID is null");
            return (Criteria) this;
        }

        public Criteria andProjectidIsNotNull() {
            addCriterion("PROJECTID is not null");
            return (Criteria) this;
        }

        public Criteria andProjectidEqualTo(String value) {
            addCriterion("PROJECTID =", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidNotEqualTo(String value) {
            addCriterion("PROJECTID <>", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidGreaterThan(String value) {
            addCriterion("PROJECTID >", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidGreaterThanOrEqualTo(String value) {
            addCriterion("PROJECTID >=", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidLessThan(String value) {
            addCriterion("PROJECTID <", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidLessThanOrEqualTo(String value) {
            addCriterion("PROJECTID <=", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidLike(String value) {
            addCriterion("PROJECTID like", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidNotLike(String value) {
            addCriterion("PROJECTID not like", value, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidIn(List<String> values) {
            addCriterion("PROJECTID in", values, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidNotIn(List<String> values) {
            addCriterion("PROJECTID not in", values, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidBetween(String value1, String value2) {
            addCriterion("PROJECTID between", value1, value2, "projectid");
            return (Criteria) this;
        }

        public Criteria andProjectidNotBetween(String value1, String value2) {
            addCriterion("PROJECTID not between", value1, value2, "projectid");
            return (Criteria) this;
        }

        public Criteria andLineidIsNull() {
            addCriterion("LINEID is null");
            return (Criteria) this;
        }

        public Criteria andLineidIsNotNull() {
            addCriterion("LINEID is not null");
            return (Criteria) this;
        }

        public Criteria andLineidEqualTo(String value) {
            addCriterion("LINEID =", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidNotEqualTo(String value) {
            addCriterion("LINEID <>", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidGreaterThan(String value) {
            addCriterion("LINEID >", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidGreaterThanOrEqualTo(String value) {
            addCriterion("LINEID >=", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidLessThan(String value) {
            addCriterion("LINEID <", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidLessThanOrEqualTo(String value) {
            addCriterion("LINEID <=", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidLike(String value) {
            addCriterion("LINEID like", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidNotLike(String value) {
            addCriterion("LINEID not like", value, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidIn(List<String> values) {
            addCriterion("LINEID in", values, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidNotIn(List<String> values) {
            addCriterion("LINEID not in", values, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidBetween(String value1, String value2) {
            addCriterion("LINEID between", value1, value2, "lineid");
            return (Criteria) this;
        }

        public Criteria andLineidNotBetween(String value1, String value2) {
            addCriterion("LINEID not between", value1, value2, "lineid");
            return (Criteria) this;
        }
    }

    /**
     * This class was generated by MyBatis Generator.
     * This class corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated do_not_delete_during_merge
     */
    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    /**
     * This class was generated by MyBatis Generator.
     * This class corresponds to the database table inputoroutputspeedtotal
     *
     * @mbg.generated
     */
    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}