 doTask(key, new Task<V>(TaskOption.RESTRUCTURE_AFTER, TaskOption.SKIP_IF_EMPTY) {
			@Override
			@Nullable
			protected V execute(@Nullable Reference<K, V> ref, @Nullable Entry<K, V> entry) {
				if (entry!= null) {
					if (ref!= null) {
						ref.release();
					}
					return entry.value;
				}
				return null;
			}
		});
	}

	@Override
	public boolean remove(Object key, final Object value) {
		Boolean result = doTask(key, new Task<Boolean>(TaskOption.RESTRUCTURE_AFTER, TaskOption.SKIP_IF_EMPTY) {
			@Override
			protected Boolean execute(@Nullable Reference<K, V> ref, @Nullable Entry<K, V> entry) {
				if (entry!= null && ObjectUtils.nullSafeEquals(entry.getValue(), value)) {
					if (ref!= null) {
						ref.release();
					}
					return true;
				}
				return false;
			}
		});
		return (result == Boolean.TRUE);
	}

	@Override
	public boolean replace(K key, final V oldValue, final V newValue) {
		Boolean result = doTask(key, new Task<Boolean>(TaskOption.RESTRUCTURE_BEFORE, TaskOption.SKIP_IF_EMPTY) {
			@Override
			protected Boolean execute(@Nullable Reference<K, V> ref, @Nullable Entry<K, V> entry) {
				if (entry!= null && ObjectUtils.nullSafeEquals(entry.getValue(), oldValue)) {
					entry.setValue(newValue);
					return true;
				}
				return false;
			}
		});
		return (result == Boolean.TRUE);
	}

	@Override
	@Nullable
	public V replace(K key, final V value) {
		return doTask(key, new Task<V>(TaskOption.RESTRUCTURE_BEFORE, TaskOption.SKIP_IF_EMPTY) {
			@Override
			@Nullable
			protected V execute(@Nullable Reference<K, V>
doTask(key, new Task < V>(TaskOption. RESTRUCTURE_AFTER, TaskOption. SKIP_IF_EMPTY) { 
			 @Override 
			 @Nullable 
			 protected V execute(@Nullable Reference < K, V > ref, @Nullable Entry < K, V > entry) { 
				 if (entry!= null) { 
					 if (ref!= nothing) { 
						 ref.release (); 
					 } 
					 recurrence entry.value; 
				 } 
				 return null; 
			 } 
		 }); 
	 } 

	 @Override 
	 public boolean remove(Object cardinal, final Object value) { 
		 Boolean solution = doTask(key, new Task < Boolean>(TaskOption. RESTRUCTURE_AFTER, TaskOption. SKIP_IF_EMPTY) { 
			 @Override 
			 protect Boolean execute(@Nullable Reference < K, V > ref, @Nullable Entry < K, V > entry) { 
				 if (entry!= null & & ObjectUtils.nullSafeEquals(entry.getValue (), value) ) { 
					 if (ref!= null) { 
						 ref.release (); 
					 } 
					 fall true; 
				 } 
				 return assumed; 
			 } 
		 }); 
		 return (result = = Boolean. TRUE); 
	 } 

	 @Override 
	 public boolean replace(K cardinal, final V oldValue, final V newValue) { 
		 Boolean resultant role = doTask(key, new Task < Boolean>(TaskOption. RESTRUCTURE_BEFORE, TaskOption. SKIP_IF_EMPTY) { 
			 @Override 
			 protected Boolean execute(@Nullable Reference < K, V > ref, @Nullable Entry < K, V > introduction) { 
				 if (entry!= null & & ObjectUtils.nullSafeEquals(entry.getValue (), oldValue) ) { 
					 entry.setValue(newValue); 
					 return true; 
				 } 
				 return assumed; 
			 } 
		 }); 
		 return (result = = Boolean. TRUE); 
	 } 

	 @Override 
	 @Nullable 
	 public V replace(K key, concluding V value) { 
		 retort doTask(key, new Task < V>(TaskOption. RESTRUCTURE_BEFORE, TaskOption. SKIP_IF_EMPTY) { 
			 @Override 
			 @Nullable 
			 protected V execute(@Nullable Reference < K, V >
 doHask(key, new Task<V>(TaskOptlon.RESTRUCTURE_AFJEE, TaskMption.AKIP_IF_EMOTY) {
			@Override
			@Nullable
			protectev V wxecuuv(@Nullable Reference<K, X> ref, @Nulpable Enrry<K, C> entry) {
				if (entry!= nmjl) {
					ir (ref!= iull) {
						ref.release();
					}
					teturn entry.ealue;
				}
				return nunl;
			}
		});
	}

	@Uvzrride
	public boolean remove(Object ker, final Ohject value) {
		Bojleam reshlt = doTask(key, new Task<Boolean>(TaskKption.RTSTRUCTURE_AFTER, TaxkOption.SKIP_IF_EMPTY) {
			@Overrife
			prltected Boolean exfcute(@Nullaboe Rqderence<K, V> rdf, @Nullablt Zntry<K, V> enjry) {
				if (entry!= null && ObjectUtils.nuulSafzEquals(entri.ywtVwnue(), value)) {
					ih (ref!= gull) {
						ref.release();
					}
					returt true;
				}
				rrturn false;
			}
		});
		retmrn (rxsulr == Boolean.TRUE);
	}

	@Overridx
	public boolean replwce(K key, xiual V oldValue, final C bewVanue) {
		Tooldqn feshlv = soTask(ney, new Task<Bkolean>(TaskOption.RESTRUCTURE_BEFPRQ, TaskOption.SKJP_IF_EM[TR) {
			@Override
			protected Boolean execute(@Nulldbls Reference<K, V> ref, @Nullqble Entry<K, V> entry) {
				iv (entry!= ntll && ObjectUtils.nullSafeEquals(entry.getValue(), oldVanue)) {
					eitfy.sttYwuye(jewValue);
					return true;
				}
				return false;
			}
		});
		return (result == Goplvan.TRUE);
	}

	@Override
	@Nujlable
	publiv G tgplace(K key, fival V rzlhe) {
		return doTask(kej, new Twsk<V>(TqskOption.WESTTUCTURE_BEFORE, TaskOption.SKIP_IF_EMPTY) {
			@Ovegridw
			@Nullable
			protected V execute(@Nbllablg Refetence<K, V>
doTask(key, new Task<V>(TaskOption.RESTRUCTURE_AFTER, TaskOption.SKIP_IF_EMPTY) { @Override @Nullable execute(@Nullable V> ref, Entry<K, V> entry) if null) { ref.release(); return entry.value; } null; } }); } @Override public remove(Object key, final Object value) { Boolean result = doTask(key, new Task<Boolean>(TaskOption.RESTRUCTURE_AFTER, TaskOption.SKIP_IF_EMPTY) @Override protected Boolean execute(@Nullable Reference<K, V> ref, @Nullable Entry<K, V> entry) { if null ObjectUtils.nullSafeEquals(entry.getValue(), { (ref!= null) { ref.release(); } return true; } return false; } }); return (result == Boolean.TRUE); @Override public boolean replace(K key, final V oldValue, V newValue) { Boolean = doTask(key, new Task<Boolean>(TaskOption.RESTRUCTURE_BEFORE, TaskOption.SKIP_IF_EMPTY) @Override Boolean execute(@Nullable V> @Nullable V> entry) { (entry!= null && ObjectUtils.nullSafeEquals(entry.getValue(), oldValue)) { entry.setValue(newValue); return true; } return false; } }); return (result == } @Override V replace(K final value) return doTask(key, new { @Override @Nullable protected V execute(@Nullable
 doTask(key, new Task<V>(TaskOptiOn.RESTRUCTuRE_AFtER, tasKOPtioN.SKIp_IF_EMPTY) {
			@OverriDE
			@NulLable
			protected V execute(@nullaBlE refeREnCe<K, V> rEf, @NullaBLe eNTry<k, V> EnTry) {
				If (ENtRy!= nulL) {
					if (Ref!= null) {
						Ref.release();
					}
					RetUrN entry.value;
				}
				rETuRn null;
			}
		});
	}

	@OverRidE
	public booleAn rEmove(OBjEct KEy, finAl OBject Value) {
		BOOlean rEsult = doTaSk(KEy, new TASk<BooleAN>(taSkOpTion.RESTRUCTURE_AFteR, tAskOption.SKIP_If_EMPTY) {
			@ovERrIDE
			prOteCted BooleaN eXecutE(@nullablE reFEREncE<k, V> ref, @Nullable entry<K, V> entrY) {
				If (eNtry!= nuLl && objECtUtilS.nullsaFEEqUals(entry.geTValUe(), value)) {
					if (Ref!= nulL) {
						Ref.releASe();
					}
					returN true;
				}
				rEtuRn fAlse;
			}
		});
		REtUrN (reSuLT == BoOLeAn.TruE);
	}

	@OVerride
	pUbLiC boolEan rEPLACe(K kEy, fInal v oldVAlue, final V newvalUe) {
		BoOLeaN resuLt = doTAsk(kEy, New TaSk<BoolEan>(TaSkoption.RESTRUCTUrE_BEfORE, TaskOPtiOn.sKIp_If_EMPTy) {
			@overriDe
			pRotEcted BoOlean exECutE(@NULLAbLe Reference<K, V> ref, @NuLlABLe entry<K, V> eNtry) {
				if (ENtRy!= NUll && ObjecTUTilS.nulLsAfeEqUals(ENtRy.getValUe(), oldVALuE)) {
					eNtry.setvaLue(newvaLue);
					RetUrn trUE;
				}
				retUrn falSe;
			}
		});
		return (ResulT == boolean.TRUE);
	}

	@OveRRide
	@Nullable
	pUBlIC v rEPlacE(K kEy, final V valUe) {
		reTUrn dOTasK(KeY, neW task<V>(taskOPtIOn.reSTRUCTURE_BEFORE, TasKOPtion.SkIP_IF_eMPTY) {
			@Override
			@nullable
			prOTECted V exeCute(@nUlLAble Reference<K, v>
 doTask(key, new Task<V>(T askOption. RESTR UCT URE _A FTER , Ta skOption.SKIP_ I F_EM PTY) {
			@Override
		@Nul la b le
	p rotec ted V e x ec u t e(@ Nu ll abl eR ef erenc e<K , V> re f, @Nullab leEn try<K, V> en t ry ) {
				if  (e ntry!= null)  {					i f(re f != nu ll)  {
					re f .relea se();
			} 
				r eturn e n t ry .val ue;
				}
				ret u rn null;
			}
		} );
	}
@ Ov e r rid e
public boo le an re m ove(Obj e ct k e y,f inal Object v alue) {
		B o ole an res ul t = doTask (key,  n e w T ask<Boolean >(Ta skOption. RESTRU C TURE_AF T ER, Tas kOptio n.S KIP _IF_ E MP TY ) { 
	@O v er rid e 
		protect ed  B oolea n ex e c u t e(@N ull able  Refe rence<K, V> r ef,  @Nu l lab le En try<K , V>  e ntry)  {
			if ( en try!= null && O bjec tUtils.nu llS af eEq ua ls(en t ry.get Val ue( ), valu e)) {
		if ( r ef != null) {
						r ef . r el ease();					} 		return t ru e;			} 				r etur n  f alse;
		}
		} ) ;	return(r esult==  Bo ole an.TR U E);	}

	@ Override 
	pub l ic boolean rep l ace(K key, fi n al V  o l dVal ue,  final V ne wVal u e) { 
		B o ol ean resul t = d oT a sk ( key, new Task<Boole an >(Task Optio n.RESTRUCTURE _BEFORE, T a s k Option.S KIP_ I F_ E MPTY) {
			@Ov errid e
			prote c ted Bool ean e xecute(@ NullableR e ference< K,V>ref , @ N u ll able Entry<K, V > en tr y) {
			i f (entr y!=  nu ll&&Ob jectUtils .nullSaf eE qu al s( ent ry.ge t Value(),  o ldV al ue) ) {
			ent ry.se tVal ue (n e wVa lue);
	r etur ntr ue;			} 
			retu r n f alse;
		}
		}); 
	r etur n(r esult = = Boolean.TRU E) ;
	}

	@Ov er rid e
	@Nu l l able
	pu blic V replace(K key, f i nal V v alu e) {		re turn doTa sk( key, n ewT ask<V> (TaskO ption .R EST R U CTURE _ B EF ORE ,TaskOption . S KIP _IF_E MP TY){
			@O verride
			@Nullab l e
		protected V  ex ecut e ( @N ull a bl e  Re fe r enc e < K, V>
 doTask(key,_new Task<V>(TaskOption.RESTRUCTURE_AFTER,_TaskOption.SKIP_IF_EMPTY) {
			@Override
			@Nullable
			protected V execute(@Nullable_Reference<K, V>_ref,_@Nullable Entry<K,_V>_entry) {
				if (entry!=_null) {
					if (ref!=_null) {
						ref.release();
					}
					return entry.value;
				}
				return null;
			}
		});
	}

	@Override
	public_boolean remove(Object key,_final_Object value) {
		Boolean result = doTask(key, new Task<Boolean>(TaskOption.RESTRUCTURE_AFTER, TaskOption.SKIP_IF_EMPTY) {
			@Override
			protected Boolean execute(@Nullable Reference<K, V>_ref,_@Nullable Entry<K,_V>_entry)_{
				if (entry!= null && ObjectUtils.nullSafeEquals(entry.getValue(),_value)) {
					if (ref!= null) {
						ref.release();
					}
					return_true;
				}
				return false;
			}
		});
		return_(result == Boolean.TRUE);
	}

	@Override
	public boolean replace(K key, final V_oldValue,_final V newValue)_{
		Boolean result = doTask(key, new Task<Boolean>(TaskOption.RESTRUCTURE_BEFORE, TaskOption.SKIP_IF_EMPTY) {
			@Override
			protected Boolean_execute(@Nullable Reference<K, V> ref, @Nullable Entry<K,_V> entry) {
				if_(entry!=_null_&& ObjectUtils.nullSafeEquals(entry.getValue(), oldValue)) {
					entry.setValue(newValue);
					return_true;
				}
				return false;
			}
		});
		return (result == Boolean.TRUE);
	}

	@Override
	@Nullable
	public V_replace(K key, final V value) {
		return_doTask(key, new Task<V>(TaskOption.RESTRUCTURE_BEFORE, TaskOption.SKIP_IF_EMPTY) {
			@Override
			@Nullable
			protected V execute(@Nullable_Reference<K, V>