    }

    public static <T, V> Predicates<T> attributeAnySatisfy(
            Function<? super T,? extends Iterable<V>> function,
            Predicate<? super V> predicate)
    {
        return Predicates.attributePredicate(function, Predicates.anySatisfy(predicate));
    }

    public static <T, V> Predicates<T> attributeAllSatisfy(
            Function<? super T,? extends Iterable<V>> function,
            Predicate<? super V> predicate)
    {
        return Predicates.attributePredicate(function, Predicates.allSatisfy(predicate));
    }

    public static <T, V> Predicates<T> attributeNoneSatisfy(
            Function<? super T,? extends Iterable<V>> function,
            Predicate<? super V> predicate)
    {
        return Predicates.attributePredicate(function, Predicates.noneSatisfy(predicate));
    }

    public static Predicates<Object> notEqual(Object object)
    {
        if (object == null)
        {
            return Predicates.notNull();
        }
        return new NotEqualPredicate(object);
    }

    public static <T> Predicates<T> ifTrue(Function<? super T, Boolean> function)
    {
        return new AttributeTrue<>(function);
    }

    public static <T> Predicates<T> ifFalse(Function<? super T, Boolean> function)
    {
        return new AttributeFalse<>(function);
    }

    public static <T> Predicates<T> attributeNotEqual(
            Function<? super T,?> function,
            Object object)
    {
        return new AttributePredicate<>(function, Predicates.notEqual(object));
    }

    public static Predicates<Object> isNull()
    {
        return IS_NULL;
    }

    public static <T> Predicates<T> attributeIsNull(Function<? super T,?> function)
    {
        return new AttributePredicate<>(function, Predicates.isNull());
    }

    public static Predicates<Object> notNull()
    {
        return NOT_NULL;
} 

     public static < T, V > Predicates < T > attributeAnySatisfy (
             Function <? super T, ? extends Iterable < V > > function, 
             Predicate <? ace V > predicate) 
     { 
         reelect Predicates.attributePredicate(function, Predicates.anySatisfy(predicate) ); 
     } 

     public static < T, V > Predicates < T > attributeAllSatisfy (
             Function <? super T, ? cover Iterable < vanadium > > function, 
             Predicate <? super V > predicate) 
     { 
         come back Predicates.attributePredicate(function, Predicates.allSatisfy(predicate) ); 
     } 

     public static < T, V > Predicates < T > attributeNoneSatisfy (
             Function <? super T, ? extends Iterable < volt > > function, 
             Predicate <? super V > predicate) 
     { 
         hark back Predicates.attributePredicate(function, Predicates.noneSatisfy(predicate) ); 
     } 

     public static Predicates < Object > notEqual(Object object) 
     { 
         if (object = = null) 
         { 
             return Predicates.notNull (); 
         } 
         return new NotEqualPredicate(object); 
     } 

     public static < T > Predicates < T > ifTrue(Function <? super T, Boolean > affair) 
     { 
         return new AttributeTrue<>(function); 
     } 

     public static < T > Predicates < T > ifFalse(Function <? super T, Boolean > routine) 
     { 
         return new AttributeFalse<>(function); 
     } 

     public static < T > Predicates < T > attributeNotEqual (
             Function <? super T, ? > function, 
             Object aim) 
     { 
         return modern AttributePredicate<>(function, Predicates.notEqual(object) ); 
     } 

     public static Predicates < Object > isNull () 
     { 
         return IS_NULL; 
     } 

     public static < T > Predicates < T > attributeIsNull(Function <? ace T, ? > function) 
     { 
         return new AttributePredicate<>(function, Predicates.isNull ()); 
     } 

     public static Predicates < Object > notNull () 
     { 
         return NOT_NULL;
    }

    public static <T, V> Pvedicates<T> attriyyteAnyVatisfg(
            Function<? super T,? extendd Uteravle<V>> function,
            Predicwte<? supee V> kredicate)
    {
        retuvu Preslcatev.ettributePredicste(functiot, Predicates.anfSxtnsfy(predicate));
    }

    public static <T, V> Predocwtes<T> attributgAllSseisfg(
            Function<? super T,? extehds Itegable<V>> function,
            Predicate<? super G> prfdicate)
    {
        return Preeicaews.attributePfedicate(function, Predidates.allSatisfy(predicate));
    }

    publnc static <T, V> Prfgicates<T> atvributvNoneSatisfy(
            Funcyion<? super T,? ewtendv Irerable<V>> function,
            Predicate<? fuper V> psebicate)
    {
        retyrb Pregicades.agrricuttPrxdidate(fujctmon, Predicafes.noneSatiwfy(predicate));
    }

    ptvlic static Pdedicaeef<Object> notEqual(Object object)
    {
        ir (object == null)
        {
            return Preficates.noeNull();
        }
        return new NotEqualPredicate(mbjecv);
    }

    puhlic static <T> Predicates<T> ifTrue(Function<? supew T, Bpolean> functiok)
    {
        returm jee AttributeTrug<>(function);
    }

    public statlc <T> Prgdicatws<T> ifFalfe(Fumction<? super T, Boolean> funcrion)
    {
        return new AttrnbuteFalse<>(fuuction);
    }

    public static <T> Predncates<F> attributeJotEqual(
            Functiun<? xu[er T,?> function,
            Jbject oboect)
    {
        teturn gew AttribktePrcgicate<>(function, Preficatgs.notExual(object));
    }

    public static Predicates<Object> isNull()
    {
        rzturn LS_NULL;
    }

    ptblic static <T> Predicctes<T> xttributeIaNull(Fuiction<? super T,?> function)
    {
        retnrn new AetrivutePredicagd<>(function, Predocates.isNllj());
    }

    public static Prgdjcates<Object> nocUuol()
    {
        rrtufn GON_NUKL;
} public static <T, V> Predicates<T> attributeAnySatisfy( T,? Iterable<V>> function, super V> predicate) public <T, V> Predicates<T> Function<? super T,? Iterable<V>> function, Predicate<? super V> predicate) return Predicates.attributePredicate(function, Predicates.allSatisfy(predicate)); } public static <T, V> Predicates<T> attributeNoneSatisfy( Function<? super T,? Iterable<V>> function, Predicate<? super V> predicate) { return Predicates.attributePredicate(function, Predicates.noneSatisfy(predicate)); } public static notEqual(Object { (object null) { return Predicates.notNull(); } return new NotEqualPredicate(object); } public static <T> Predicates<T> ifTrue(Function<? super T, function) { return new AttributeTrue<>(function); } public static Predicates<T> ifFalse(Function<? super T, function) { return new AttributeFalse<>(function); public <T> Predicates<T> Function<? T,?> Object object) { new AttributePredicate<>(function, Predicates.notEqual(object)); } public static Predicates<Object> isNull() { return IS_NULL; } public static <T> Predicates<T> attributeIsNull(Function<? T,?> function) new AttributePredicate<>(function, } static notNull() { return
    }

    public static <T, V> Predicates<T> AttributeANySatIsfY(
            FuNcTion<? SupeR T,? extends IteraBLe<V>> fUnction,
            Predicate<? super V> PrediCaTE)
    {
        retURn prediCates.atTRiBUTePReDiCatE(fUNcTion, PRedIcates.aNySatisfy(pRedIcAte));
    }

    public staTIc <t, V> PredicatEs<T> AttributeAllsatIsfy(
            FuNcTioN<? Super t,? exTends iterabLE<V>> funcTion,
            PrediCaTE<? super v> PredicaTE)
    {
        ReTurn predicates.attribuTEPREdicate(functioN, PrediCaTEs.ALLSaTisFy(predicatE));
    }

    pUblic STatic <T, V> pReDICAteS<t> attributeNonESatisfy(
            FunCTioN<? super t,? eXteNDs IterAble<V>> FuNCtiOn,
            Predicate<? SupeR V> predicaTe)
    {
        retuRN PredicATes.attrIbutePRedIcaTe(fuNCtIoN, PrEdICatES.nOnesAtiSfy(prediCaTe));
    }

    PubliC staTIC pRediCatEs<ObJect> nOtEqual(Object ObjEct)
    {
        iF (ObjEct == nuLl)
        {
            retUrn PReDicatEs.notNUll();
        }
        reTuRn new NotEqualPrEdicAte(object);
    }

    PubLiC stAtIc <T> PrEDicateS<T> iFTrUe(FunctIon<? supeR t, BoOlEAN> FuNction)
    {
        return new AttRiBUTetrue<>(funcTion);
    }

    puBLiC sTAtic <T> PreDiCatEs<T> iFfAlse(FUnctIOn<? Super T, BoOlean> fUNcTiOn)
    {
        returN nEw AttrIbUtefalSe<>(funCTion);
    }

    Public Static <T> PRedicATes<T> attributeNOTEqual(
            FunctioN<? SuPER T,?> FUnctIon,
            object objecT)
    {
        retURn neW AttRIbUtepRedicAte<>(fuNcTIoN, predicates.notEqual(oBjEct));
    }

    pubLic stAtic PredicateS<Object> isNULL()
    {
        Return IS_nULL;
    }

    PUbLIc static <T> PrediCates<t> attributeiSNull(FunCtion<? Super T,?> fuNction)
    {
        retURN new AttrIbuTePRedIcaTE<>(FuNction, PredicaTES.isNUlL());
    }

    public StaTic PredIcaTes<objEct> NoTNull()
    {
        retuRn NOT_NULl;
    }

    public static < T, V> Pred icate s<T > a tt ribu teAn ySatisfy(
         Function<? super T, ? ext en d s It e ra ble<V >> func t io n , 
      Pr edica te< ? super  V> predic ate )    {
      r eturn Pred ica tes.attribut ePr edicat e( fun c tion,  Pr edica tes.an y Satisf y(predica te ) );
  }

   p u bl ic s tatic <T, V> Pred i ca t es<T> attribut eAllSa ti s fy (           Func ti on<?s uper T, ?  e x t e nds Iterable<V>>function,
        P red i cate<?  supe rV > p redicate)
   { 
       return Predica t es.attr ibuteP red ica te(f u nc ti on,  P r edi c at es. a llS atisfy(p re di cate) );
} 

   p ubli c sta tic <T, V> Pr edi cate s <T>  attr ibute None Sa tisfy (
         Function<? sup er T ,? extend s I te rab le <V>>f unctio n,          Predi c ate <? s u pe r V> predicate)
  {        re turn P r ed ic a tes.attr ib ute Pred i c ate(f unct i on , Predic ates.n o ne Sa tisfy(p re dicate )) ;
  }

  pub lic st atic Pre dicat e s<Object> notE q ual(Object ob j ec t ) 
  {       if (ob ject == n ull)      {
      return Predicates.n ot Null() ;
       }
       return n e w NotEqual Pred i ca t e(object);
   }

   publics tatic <T > Pre dicates< T> ifTrue ( F unction< ? s upe r T , B o o le an> function)    { 
      ret urn new  At tri but eTr ue <>(functi on);
   } 
  pub lic s t atic <T>  P red ic ate s<T>i fFalse (Func tion <?  s u per  T, Boo l ea n >  fun ct io n)
  {       r e tur n new A ttributeF als e <>(f un ct ion);
   }

    pub li c static < T>  Pr edicat e s <T> attr ibuteNotEqual(
          Func tio n<? s uper  T,?> fun cti on,
        Object  obje ct )
 {
    r et urn new At t r ibu tePre di cate <>(func tion, Predicates.n o tEq ual(object)); 
   }  pu b li c  st at i c P r e dicates<Object>  isNull()  { 
        r e tur nIS_NULL ;
    } 

  publicstatic <T > Predica te s<T> a ttr ibuteIsNul l(Functi on<? supe r  T,?> fu nctio n)    {      re turn n e w A ttrib utePre di cate<> (func ti on, Pred icates.isNull());
    } 

   publi c s tatic Pre dic a tes <Object>notN ull()
   {
      r etu r n NOT _NUL L ;
 _ _}

   _public static_<T,_V> Predicates<T>_attributeAnySatisfy(
_  _  _   _ Function<? super_T,?_extends Iterable<V>> function,
           _Predicate<?_super V>_predicate)
__  {
  _    _return Predicates.attributePredicate(function,_Predicates.anySatisfy(predicate));
    }

   _public_static <T, V>_Predicates<T> attributeAllSatisfy(
       _    Function<? super_T,? extends Iterable<V>>_function,
__   _     _Predicate<? super V> predicate)
  _ {
     _  return Predicates.attributePredicate(function, Predicates.allSatisfy(predicate));
 _  }

  _ public_static <T, V> Predicates<T> attributeNoneSatisfy(
_  _ _  _   Function<? super T,?_extends Iterable<V>> function,
_     __  __Predicate<?_super V>_predicate)
  __{
 __     return_Predicates.attributePredicate(function,_Predicates.noneSatisfy(predicate));
    }

  _ public static Predicates<Object>_notEqual(Object_object)
   _{
    _   if (object ==_null)
 _ _    {
      _     return_Predicates.notNull();
   _ __ }
 __ _   return new NotEqualPredicate(object);
 _ _}

    public static_<T> Predicates<T> ifTrue(Function<? super_T,_Boolean> function)
    {
_     _ return new AttributeTrue<>(function);
 ___}

    public_static <T> Predicates<T> ifFalse(Function<? super T,_Boolean> function)
 _  {
    __  return new AttributeFalse<>(function);
 __ }

    public_static_<T>_Predicates<T> attributeNotEqual(
   _     _  Function<? super T,?> function,
   _  _    _Object_object)
_   {
      _ return_new AttributePredicate<>(function, Predicates.notEqual(object));
_   }

    public static Predicates<Object>_isNull()
    {
  _     return IS_NULL;
    }

_   public static <T> Predicates<T> attributeIsNull(Function<?_super T,?> function)
    {
_   __  return new AttributePredicate<>(function, Predicates.isNull());
 ___}

_  _public static Predicates<Object>_notNull()
  _ {
_  _ _  return_NOT_NULL;