typedef __mpz_struct mpz_t[1];

Cgo generates:

	type _C_int int32
	type _C_mp_limb_t uint64
	type _C___mpz_struct struct {
		_mp_alloc _C_int;
		_mp_size _C_int;
		_mp_d *_C_mp_limb_t;
	}
	type _C_mpz_t [1]_C___mpz_struct

and then replaces each occurrence of a type C.xxx with _C_xxx.

If xxx is data, cgo arranges for C.xxx to refer to the C variable,
with the type translated as described above.  To do this, cgo must

   * that conversion is safe.
   *
   * <p>This method is intended to help with usages of type parameters that have {@linkplain
   * ParametricNullness parametric nullness}. If a type parameter instead ranges over only non-null
   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from

        }
    }

    /**
     * Copies the source Bean to a new instance of the destination Bean and returns it.
     *
     * @param <T> The type of the destination Bean.
     * @param src The source Bean. Must not be {@literal null}.
     * @param destClass The type of the destination Bean. Must not be {@literal null}.
     * @return The newly copied Bean.
     */

    for (Class<?> type : types) {
      assertFreshInstance(type, 2);
    }
  }

  private static void assertFreshInstance(TypeToken<?> type) {
    assertFreshInstance(type, 3);
  }

  private static void assertFreshInstance(Class<?> type, int instances) {
    assertFreshInstance(TypeToken.of(type), instances);
  }

package clause

import (
	"strings"
)

const (
	AndWithSpace = " AND "
	OrWithSpace  = " OR "
)

// Where where clause
type Where struct {
	Exprs []Expression
}

// Name where clause name
func (where Where) Name() string {
	return "WHERE"
}

// Build build where clause
func (where Where) Build(builder Builder) {
	if len(where.Exprs) == 1 {
		if andCondition, ok := where.Exprs[0].(AndConditions); ok {

# conditionBeanMap: (NotRequired - Default map:{})
#
# Specification:
# map:{
#     ; [property-type] = map:{
#         ; [condition-key] = map:{ [table] = list:{ [column] ; [column] } }
# }
#
# property-type: String, Number, Date, OrderBy, ...
# condition-key: NotEqual, GreaterThan, LessThan, GreaterEqual, LessEqual

    extends AbstractBiMap<K, V> {
  transient Class<K> keyTypeOrObjectUnderJ2cl;

  /**
   * Returns a new, empty {@code EnumHashBiMap} using the specified key type.
   *
   * @param keyType the key type
   */
  public static <K extends Enum<K>, V extends @Nullable Object> EnumHashBiMap<K, V> create(
      Class<K> keyType) {
    return new EnumHashBiMap<>(keyType);
  }

  /**

pkg syscall (netbsd-arm64-cgo), type Cmsghdr struct, Type int32
pkg syscall (netbsd-arm64-cgo), type Credential struct
pkg syscall (netbsd-arm64-cgo), type Credential struct, Gid uint32
pkg syscall (netbsd-arm64-cgo), type Credential struct, Groups []uint32
pkg syscall (netbsd-arm64-cgo), type Credential struct, NoSetGroups bool
pkg syscall (netbsd-arm64-cgo), type Credential struct, Uid uint32

        this.sessionId = sessionId;
    }

    /**
     * Returns the filter type.
     * @return The filter type.
     */
    public String getFilterType() {
        return filterType;
    }

    /**
     * Sets the filter type.
     * @param filterType The filter type.
     */
    public void setFilterType(final String filterType) {
        this.filterType = filterType;
    }

ations | indent 4 }} {{- end }} spec: {{- if (or (eq .Values.service.type "ClusterIP" "") (empty .Values.service.type)) }} type: ClusterIP {{- if not (empty .Values.service.clusterIP) }} clusterIP: {{ .Values.service.clusterIP }} {{end}} {{- else if eq .Values.service.type "LoadBalancer" }} type: {{ .Values.service.type }} loadBalancerIP: {{ default "" .Values.service.loadBalancerIP }} {{- else }} type: {{ .Values.service.type }} {{- end }} ports: - name: {{ $scheme }} port: {{ .Values.service.port...