gt:                 value = valueDes.getNullValue(ctxt);
context: package com.fasterxml.jackson.databind.deser.std;
  
  import java.io.IOException;
  import java.util.*;
  
  import com.fasterxml.jackson.core.*;
  import com.fasterxml.jackson.databind.*;
  import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
  import com.fasterxml.jackson.databind.deser.*;
  import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
  
  /**
   * Basic serializer that can take JSON "Object" structure and
   * construct a {@link java.util.Map} instance, with typed contents.
   *<p>
   * Note: for untyped content (one indicated by passing Object.class
   * as the type), {@link UntypedObjectDeserializer} is used instead.
   * It can also construct {@link java.util.Map}s, but not with specific
   * POJO types, only other containers and primitives/wrappers.
   */
  @JacksonStdImpl
  public class MapEntryDeserializer
      extends ContainerDeserializerBase<Map.Entry<Object,Object>>
      implements ContextualDeserializer
  {
      private static final long serialVersionUID = 1;
  
      // // Configuration: typing, deserializers
  
      protected final JavaType _type;
  
      /**
       * Key deserializer to use; either passed via constructor
       * (when indicated by annotations), or resolved when
       * {@link #createContextual} is called;
       */
      protected final KeyDeserializer _keyDeserializer;
  
      /**
       * Value deserializer.
       */
      protected final JsonDeserializer<Object> _valueDeserializer;
  
      /**
       * If value instances have polymorphic type information, this
       * is the type deserializer that can handle it
       */
      protected final TypeDeserializer _valueTypeDeserializer;
  
      /*
      /**********************************************************
      /* Life-cycle
      /**********************************************************
       */
  
      public MapEntryDeserializer(JavaType type,
              KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
              TypeDeserializer valueTypeDeser)
      {
          super(type);
          if (type.containedTypeCount() != 2) { // sanity check
              throw new IllegalArgumentException("Missing generic type information for "+type);
          }
          _type = type;
          _keyDeserializer = keyDeser;
          _valueDeserializer = valueDeser;
          _valueTypeDeserializer = valueTypeDeser;
      }
  
      /**
       * Copy-constructor that can be used by sub-classes to allow
       * copy-on-write styling copying of settings of an existing instance.
       */
      protected MapEntryDeserializer(MapEntryDeserializer src)
      {
          super(src._type);
          _type = src._type;
          _keyDeserializer = src._keyDeserializer;
          _valueDeserializer = src._valueDeserializer;
          _valueTypeDeserializer = src._valueTypeDeserializer;
      }
  
      protected MapEntryDeserializer(MapEntryDeserializer src,
              KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
              TypeDeserializer valueTypeDeser)
      {
          super(src._type);
          _type = src._type;
          _keyDeserializer = keyDeser;
          _valueDeserializer = valueDeser;
          _valueTypeDeserializer = valueTypeDeser;
      }
  
      /**
       * Fluent factory method used to create a copy with slightly
       * different settings. When sub-classing, MUST be overridden.
       */
      @SuppressWarnings("unchecked")
      protected MapEntryDeserializer withResolved(KeyDeserializer keyDeser,
              TypeDeserializer valueTypeDeser, JsonDeserializer<?> valueDeser)
      {
          
          if ((_keyDeserializer == keyDeser) && (_valueDeserializer == valueDeser)
                  && (_valueTypeDeserializer == valueTypeDeser)) {
              return this;
          }
          return new MapEntryDeserializer(this,
                  keyDeser, (JsonDeserializer<Object>) valueDeser, valueTypeDeser);
      }
  
      /*
      /**********************************************************
      /* Validation, post-processing (ResolvableDeserializer)
      /**********************************************************
       */
  
      /**
       * Method called to finalize setup of this deserializer,
       * when it is known for which property deserializer is needed for.
       */
      @Override
      public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
              BeanProperty property) throws JsonMappingException
      {
          KeyDeserializer kd = _keyDeserializer;
          if (kd == null) {
              kd = ctxt.findKeyDeserializer(_type.containedType(0), property);
          } else {
              if (kd instanceof ContextualKeyDeserializer) {
                  kd = ((ContextualKeyDeserializer) kd).createContextual(ctxt, property);
              }
          }
          JsonDeserializer<?> vd = _valueDeserializer;
          vd = findConvertingContentDeserializer(ctxt, property, vd);
          JavaType contentType = _type.containedType(1);
          if (vd == null) {
              vd = ctxt.findContextualValueDeserializer(contentType, property);
          } else { // if directly assigned, probably not yet contextual, so:
              vd = ctxt.handleSecondaryContextualization(vd, property, contentType);
          }
          TypeDeserializer vtd = _valueTypeDeserializer;
          if (vtd != null) {
              vtd = vtd.forProperty(property);
          }
          return withResolved(kd, vtd, vd);
      }
  
      /*
      /**********************************************************
      /* ContainerDeserializerBase API
      /**********************************************************
       */
  
      @Override
      public JavaType getContentType() {
          return _type.containedType(1);
      }
  
      @Override
      public JsonDeserializer<Object> getContentDeserializer() {
          return _valueDeserializer;
      }
      
      /*
      /**********************************************************
      /* JsonDeserializer API
      /**********************************************************
       */
  
      @Override
      public Map.Entry<Object,Object> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
      {
          // Ok: must point to START_OBJECT, FIELD_NAME or END_OBJECT
          JsonToken t = jp.getCurrentToken();
          if (t != JsonToken.START_OBJECT && t != JsonToken.FIELD_NAME && t != JsonToken.END_OBJECT) {
              // String may be ok however:
              // slightly redundant (since String was passed above), but
              return _deserializeFromEmpty(jp, ctxt);
          }
          if (t == JsonToken.START_OBJECT) {
              t = jp.nextToken();
          }
          if (t != JsonToken.FIELD_NAME) {
              if (t == JsonToken.END_OBJECT) {
                  ctxt.reportMappingException("Can not deserialize a Map.Entry out of empty JSON Object");
                  return null;
              }
              ctxt.reportMappingException(handledType(), t);
              return null;
          }
          
          final KeyDeserializer keyDes = _keyDeserializer;
          final JsonDeserializer<Object> valueDes = _valueDeserializer;
          final TypeDeserializer typeDeser = _valueTypeDeserializer;
  
          final String keyStr = jp.getCurrentName();
          Object key = keyDes.deserializeKey(keyStr, ctxt);
          Object value = null;
          // And then the value...
          t = jp.nextToken();
          try {
              // Note: must handle null explicitly here; value deserializers won't
              if (t == JsonToken.VALUE_NULL) {
  