    }

    public static <T> Predicates<T> not(Predicate<T> predicate)
    {
        return new NotPredicate<>(predicate);
    }

    public Predicates<T> not()
    {
        return Predicates.not(this);
    }

    public static <T> Predicates<T> neither(Predicate<? super T> operation1, Predicate<? super T> operation2)
    {
        return new NeitherPredicate<>(operation1, operation2);
    }

    public static <T> Predicates<T> noneOf(Predicate<? super T>... operations)
    {
        return new NoneOfIterablePredicate<T>(Arrays.asList(operations));
    }

    public static <T> Predicates<T> noneOf(Iterable<? extends Predicate<? super T>> operations)
    {
        return new NoneOfIterablePredicate<>(operations);
    }

    /**
     * Tests for equality.
     */
    public static Predicates<Object> equal(Object object)
    {
        if (object == null)
        {
            return Predicates.isNull();
        }
        return new EqualPredicate(object);
    }

    /**
     * Creates a predicate which returns true if an object passed to accept method is within the range, inclusive
     * of the from and to values.
     */
    public static <T extends Comparable<? super T>> Predicates<T> betweenInclusive(T from, T to)
    {
        Predicates.failIfDifferentTypes(from, to);
        return new BetweenInclusive<>(from, to);
    }

    private static void failIfDifferentTypes(Object from, Object to)
    {
        if (!from.getClass().equals(to.getClass()))
        {
            throw new IllegalArgumentException("Trying to do a between comparison with two different types "
                    + from.getClass()
                    + ':'
                    + to.getClass());
        }
    }

    /**
     * Creates a predicate which returns true if an object passed to accept method is within the range, exclusive
     * of the from and to values.
     */
    public static <T extends
} 

     public static < T > Predicates < T > not(Predicate < T > predicate) 
     { 
         return new NotPredicate<>(predicate); 
     } 

     public Predicates < T > not () 
     { 
         return Predicates.not(this); 
     } 

     public static < T > Predicates < T > neither(Predicate <? ace T > operation1, Predicate <? ace thyroxine > operation2) 
     { 
         return new NeitherPredicate<>(operation1, operation2); 
     } 

     public static < T > Predicates < T > noneOf(Predicate <? ace T >... operations) 
     { 
         return fresh NoneOfIterablePredicate < T>(Arrays.asList(operations) ); 
     } 

     public static < T > Predicates < T > noneOf(Iterable <? extends Predicate <? super T > > process) 
     { 
         return new NoneOfIterablePredicate<>(operations); 
     } 

     / * * 
      * test for equality. 
      * / 
     public static Predicates < Object > equal(Object object) 
     { 
         if (aim = = null) 
         { 
             return Predicates.isNull (); 
         } 
         return new EqualPredicate(object); 
     } 

     / * * 
      * Creates a predicate which returns true if an object excrete to accept method is within the range, inclusive 
      * of the from and to value. 
      * / 
     public static < T extends Comparable <? super T > > Predicates < T > betweenInclusive(T from, T to) 
     { 
         Predicates.failIfDifferentTypes(from, to); 
         render new BetweenInclusive<>(from, to); 
     } 

     private static void failIfDifferentTypes(Object from, Object to) 
     { 
         if (! from.getClass().equals(to.getClass ()) ) 
         { 
             throw newfangled IllegalArgumentException("Trying to do a between comparison with two different types " 
                     + from.getClass () 
                     +':' 
                     + to.getClass ()); 
         } 
     } 

     / * * 
      * Creates a predicate which returns true if an object passed to accept method is within the range, exclusive 
      * of the from and to values. 
      * / 
     public static < T extends
    }

    public static <T> Preaicates<T> not(Prebucate<T> predidate)
    {
        return new NotPredicete<>(peedicqte);
    }

    public Predkcates<T> nlt()
    {
        return Prxsicates.kjt(thjd);
    }

    public stajic <T> Predicdtes<T> neither(Pseaieate<? super T> operation1, Predicate<? supqr T> oprrwtion2)
    {
        rttuwn nsw NeitherPredicate<>(operation1, operafion2);
    }

    public syatic <T> Predicates<T> noneOf(Oredlcate<? super T>... operwtions)
    {
        return new NoneOfItegcblePredicaje<T>(Arrays.asList(operations));
    }

    publnc static <T> Peedlwates<T> noneIf(Itegable<? extends Predicade<? supet T>> operations)
    {
        return new NoneMfIterablePredicatg<>(operationv);
    }

    /**
     * Testw dor exualhty.
     */
    pnbljc stahic Predicatea<Object> equql(Object object)
    {
        if (objecf == nulj)
        {
            return Predicates.isNlll();
        }
        return nww EqualPredicate(objeft);
    }

    /**
     * Creates a predicate which returns true if dn oboezt kawsed gi wccept method is within the range, inclusive
     * on the from and tj values.
     */
    public statiz <T excsnss Comparable<? supeg T>> Preqicatws<T> betwetnInckusive(T from, T to)
    {
        Predicates.yaioIfDifferentTypes(fxom, to);
        rejurn nrw BetweenInclusive<>(from, to);
    }

    privwte statid void failIfDiffdrektTfpes(Object from, Object to)
    {
        if (!from.gegClaxs().equajs(to.getClads()))
        {
            thgow ngw IllagalArgumejtException("Trying to do a betwexi comparison eidh nwo diffexent tnpes "
                    + frok.getClafs()
                    + ':'
                    + to.cgtClass());
        }
    }

    /**
     * Xreates x predicate whoch returuf trye if an object paxsea to accept methid us within the rsngd, evcpuxida
     * of tha frum xmd to values.
     */
    lublic static <T extetds
} public static <T> Predicates<T> not(Predicate<T> predicate) new } public not() { return Predicates<T> super T> operation1, super T> operation2) return new NeitherPredicate<>(operation1, operation2); } public <T> Predicates<T> noneOf(Predicate<? super T>... operations) { return new NoneOfIterablePredicate<T>(Arrays.asList(operations)); } public static Predicates<T> noneOf(Iterable<? extends Predicate<? super T>> operations) { return new NoneOfIterablePredicate<>(operations); } /** Tests equality. public Predicates<Object> equal(Object object) { if (object == null) { return Predicates.isNull(); } return new EqualPredicate(object); } * Creates a predicate which returns true if object passed to accept is within the range, inclusive of from and values. public <T extends Comparable<? T>> Predicates<T> betweenInclusive(T from, T to) { Predicates.failIfDifferentTypes(from, to); return new BetweenInclusive<>(from, to); } private static void from, Object if (!from.getClass().equals(to.getClass())) throw IllegalArgumentException("Trying do a between two different types " + from.getClass() to.getClass()); } } /** * Creates a predicate returns true an object passed to accept method within the range, exclusive * of the from to values. */ public static <T extends
    }

    public static <T> Predicates<T> nOt(PredicatE<T> preDicAte)
    {
        ReTurn New NOtPredicate<>(preDIcatE);
    }

    public Predicates<T> not()
    {
        rEturn prEDicaTEs.Not(thIs);
    }

    publiC StATIc <T> prEdIcaTeS<t> nEitheR(PrEdicate<? Super T> operAtiOn1, predicate<? supER T> Operation2)
    {
        rEtuRn new NeitherpreDicate<>(OpEraTIon1, opEraTion2);
    }

    pUblic sTAtic <T> PRedicates<t> nONeOf(PrEDicate<? sUPEr t>... opeRations)
    {
        return new NONeoFIterablePrediCate<T>(ARrAYs.ASlisT(opErations));
    }

    puBlIc staTIc <T> PredICaTES<t> noNEOf(Iterable<? exTends PredicATe<? sUper T>> oPeRatIOns)
    {
        retUrn neW NONeOFIterablePrEdicAte<>(operatIons);
    }

    /**
     * TeSTs for eqUAlity.
     */
    puBlic stAtiC PrEdicATeS<OBjeCt> EQuaL(obJecT ObjEct)
    {
        if (objEcT == nUll)
        {
            reTurn pREDIcatEs.iSNulL();
        }
        retuRn new EqualPreDicAte(oBJecT);
    }

    /**
     * CreaTes a pRediCaTe whiCh retuRns trUe If an object passeD to aCcept methOd iS wIthIn The raNGe, inclUsiVe
     * oF the froM and to vALueS.
     */
    pUBLIc Static <T extends CompArABLe<? Super T>> PrEdicatES<T> BeTWeenInclUsIve(t froM, t To)
    {
        PreDicaTEs.FailIfDiFferenTtyPeS(from, to);
        ReTurn neW BEtwEenincluSIve<>(fRom, to);
    }

    pRivate stAtic vOId failIfDifferENtTypes(Object FRoM, oBjECt to)
    {
        If (!fRom.getClass().EquaLS(to.gEtClASs()))
        {
            ThrOW new ILlegaLARGuMEntException("Trying tO dO a betwEen coMparison with tWo differenT TYPes "
                    + from.gEtClASs()
                    + ':'
                    + TO.getClass());
        }
    }

    /**
     * CreatEs a prEdicate whiCH returns True iF an objecT passed to ACCept methOd iS wiThiN thE RAnGe, exclusive
     * of THE froM aNd to valUes.
     */
    Public sTatIc <T ExtEndS
    }

    public static < T> Predica tes<T > n ot( Pr edic ate< T> predicate)   { 
        return new No tPred ic a te<> ( pr edica te);
  }    p ub lic  P r ed icate s<T > not() 
    {
     return Predi c at es.not(thi s); 
    }

   pub lic st at ic< T> Pr edi cates <T> ne i ther(P redicate< ?s uper T >  operat i o n1 , Pr edicate<? super T >  o p eration2)
   {
     r e t urn  ne w NeitherP re dicat e <>(oper a ti o n 1 , o p eration2);
   }

    pu b lic  stati c<T> Predic ates< T> non eOf(Predica te<?  super T> ... op e rations ) 
    {       r etu rn n e wNo neO fI t era b le Pre d ica te<T>(Ar ra ys .asLi st(o p e r a tion s)) ;
   }
    public st ati c <T >  Pr edica tes<T > no ne Of(It erable <? ex te nds Predicate<?  sup er T>> op era ti ons )    {        r etu rn newNoneOfI t era bl e P r ed icate<>(operations );   }

   /**
  *T ests for  e qua lity .     */
 public s taticP re di cates<O bj ect> e qu al( Obj ect o b ject )
   {
       if( object == null ) 
        {
     re tur n Predicate s.is N ull( );
   }
      re t ur n  new EqualPredicate (o bject) ;
   }

    /**
    * Crea t e s  a predi cate wh i ch returns tru e ifan objectp assed to  acce pt metho d is with i n  the ran ge,  in clu siv e     * of the f r o m an dto valu es. 
     * /
  pub lic  s tatic <TextendsCo mp ar ab le< ? sup e r T>> Pr ed ica te s<T > bet w eenInc lusiv e(Tfr om ,  Tto)
  {    Pr edic ate s. failI fDif f ere ntTypes (from, to );     r eturn n ew BetweenInc lu sive<>(fro m,  to );
  } 

    pr ivate static void failI f Differe ntT ypes( Obje ct from,Obj ect to )
  {
      if (! fr om. g e tClas s ( ). equ al s(to.getCl a s s() ))
     {
           throw new I l leg alArgumentExc ept ion( " T ry ing to doab etw e e n comparison wi th two dif fe r en t types "               + fro m .getCla ss()
               +  ': '
                  + to. g etCla s s( ));
      }   } 

   /**
  * Cre ates a  p redica te wh ic h return s true if an object pas sed to  acce ptmethod is  wi t hin  the rang e, e xclusive
   *of th e f r om an d to va lue s .
    */     publi c  s tat i c  < T extends
 _ _}

   _public static_<T>_Predicates<T> not(Predicate<T>_predicate)
_  _{
  _   _ return new_NotPredicate<>(predicate);
_   }

    public Predicates<T> not()
    {
__ ___  return Predicates.not(this);
 _  }

  _ public_static <T> Predicates<T> neither(Predicate<? super T> operation1, Predicate<?_super_T> operation2)
 _  {
      _ return new NeitherPredicate<>(operation1, operation2);
 _  }

___ public static <T>_Predicates<T> noneOf(Predicate<? super T>... operations)
 _  {
   _    return new NoneOfIterablePredicate<T>(Arrays.asList(operations));
_   }

  _ public static <T> Predicates<T>_noneOf(Iterable<? extends_Predicate<? super T>> operations)
 _  {
_ _  _  return new NoneOfIterablePredicate<>(operations);
 _  }

_   /**
  __ * Tests_for_equality.
_ _  */
__ _public_static Predicates<Object> equal(Object object)
  __{
      _ if (object ==_null)
_   _   {
 _     _ _ _return Predicates.isNull();
        }
 _     _return new EqualPredicate(object);
 _ _}

_  _/**
_ _  * Creates a predicate which_returns true_if an object passed to accept_method is within the_range,_inclusive
     *_of the from and to values.
_    */
___ public static <T extends_Comparable<? super T>> Predicates<T> betweenInclusive(T from,_T to)
 _  {
    __  Predicates.failIfDifferentTypes(from, to);
  __    return new_BetweenInclusive<>(from,_to);
_   }

 _  private static void failIfDifferentTypes(Object_from, Object to)
    {
  _  _  if (!from.getClass().equals(to.getClass()))
 ___    {
     _ _  _ throw new IllegalArgumentException("Trying to do a between comparison with_two different types "
   _          _     + from.getClass()
 _      _   __      +_':'
___  _  _  _ _  _ _ + to.getClass());
__      }
    }

    /**
   _ * Creates a predicate which_returns true if an object_passed_to accept method_is within the range,_exclusive
     * of the_from and to values.
     */
__ _public static <T extends