postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGenerated
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])

import "C"

var x = map[C.jobject]int{nil: 0}
`,
		Out: `package main

// typedef struct _jobject* jobject;
import "C"

var x = map[C.jobject]int{0: 0}
`,
	},
	{
		Name: "jni.MapValue",
		In: `package main

// typedef struct _jobject* jobject;
import "C"

var x = map[int]C.jobject{0: nil}
`,
		Out: `package main

// typedef struct _jobject* jobject;
import "C"

import "C"

var x = map[C.$EGLTYPE]int{nil: 0}
`,
			Out: `package main

// typedef void *$EGLTYPE;
import "C"

var x = map[C.$EGLTYPE]int{0: 0}
`,
		},
		{
			Name: "egl.MapValue",
			In: `package main

// typedef void *$EGLTYPE;
import "C"

var x = map[int]C.$EGLTYPE{0: nil}
`,
			Out: `package main

// typedef void *$EGLTYPE;
import "C"

					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGenerated
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])

	}
	if length != wire.ArrayT.Len {
		fmt.Fprintf(os.Stderr, "%s(wrong length for array: %d should be %d)\n", indent, length, wire.ArrayT.Len)
	}
}

// MapValue:
//
//	uint(n) (FieldValue FieldValue)*n  [n (key, value) pairs]
func (deb *debugger) mapValue(indent tab, wire *wireType) {
	keyId := wire.MapT.Key
	elemId := wire.MapT.Elem
	u := deb.uint64()
	length := int(u)
	for i := 0; i < length; i++ {

import "C"

var x = map[C.CFTypeRef]int{nil: 0}
`,
		Out: `package main

// typedef const void *CFTypeRef;
import "C"

var x = map[C.CFTypeRef]int{0: 0}
`,
	},
	{
		Name: "cftype.MapValue",
		In: `package main

// typedef const void *CFTypeRef;
import "C"

var x = map[int]C.CFTypeRef{0: nil}
`,
		Out: `package main

// typedef const void *CFTypeRef;
import "C"

			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}

            ? 'getInputs().property("input", "value");'
            : ""}
                    Map<String, Object> mapValues = new HashMap<String, Object>();
                    mapValues.put("mapInput", "mapValue");
                    ${previousVersionLeaksInternal ? "((TaskInputs)getInputs())" : "getInputs()"}.properties(mapValues);
                }

                @TaskAction
                public void doGet() {

		switch {
		case fd.IsList():
			o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
		case fd.IsMap():
			o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
		case fd.Message() != nil:
			mergeFn, exists := o.customMergeFn[fd.Message().FullName()]
			if exists {
				mergeFn(dst.Mutable(fd).Message(), v.Message())
			} else {

                    if (value instanceof Map) {
                        @SuppressWarnings("unchecked")
                        final Map<String, Object> mapValue = (Map<String, Object>) value;
                        return toLowerHyphen(mapValue);
                    }
                    return e.getValue();
                }));
    }

    public void setUserCheckInterval(final long userCheckInterval) {