if x < y {
		return x
	}
	return y
}

func lookup[M ~map[K]V, K comparable, V any](m M, k K) V {
	return m[k]
}

func deref[P ~*E, E any](p P) E {
	return *p
}

func _() int {
	p := new(int)
	return deref(p)
}

func addrOfCopy[V any, P *V](v V) P {
	return &v
}

func _() *int {
	return addrOfCopy(0)
}

	check("int64-div-zero", func() { println(1 / x64) }, "integer divide by zero")

	check("nil-deref", func() { println(p[0]) }, "nil pointer dereference")
	check("nil-deref-1", func() { println(p[1]) }, "nil pointer dereference")
	check("nil-deref-big", func() { println(q[5000]) }, "nil pointer dereference")

	i = 99999
	var sl []int
	p1 := new([10]int)

        return userProperties.get(key);
    }

    @Override
    public Model getRawModel(Path from, Path p) {
        return Holder.deref(modelByPath.get(p));
    }

    @Override
    public Model getRawModel(Path from, String groupId, String artifactId) {
        return Holder.deref(modelByGA.get(new GAKey(groupId, artifactId)));
    }

    @Override
    public Path locate(Path path) {

        return userProperties.get(key);
    }

    @Override
    public Model getRawModel(Path from, Path p) {
        return Holder.deref(modelByPath.get(p));
    }

    @Override
    public Model getRawModel(Path from, String groupId, String artifactId) {
        return Holder.deref(modelByGA.get(new GAKey(groupId, artifactId)));
    }

    @Override
    public Path locate(Path path) {

				t.Errorf("metadata.DeletionGracePeriodSeconds = %v, want %v", ptr.Deref(tt.args.pod.DeletionGracePeriodSeconds, 0), ptr.Deref(tt.wantDeletionGracePeriodSeconds, 0))
			}
			if !utilpointer.Int64Equal(tt.args.options.GracePeriodSeconds, tt.wantGracePeriodSeconds) {
				t.Errorf("options.GracePeriodSeconds = %v, want %v", ptr.Deref(tt.args.options.GracePeriodSeconds, 0), ptr.Deref(tt.wantGracePeriodSeconds, 0))
			}
		})
	}

	var warnings []string
	if spec.CompletionMode != nil && *spec.CompletionMode == batch.IndexedCompletion {
		completions := ptr.Deref(spec.Completions, 0)
		parallelism := ptr.Deref(spec.Parallelism, 0)
		if completions > completionsSoftLimit && parallelism > parallelismSoftLimitForUnlimitedCompletions {

package q1

func Deref(typ interface{}) interface{} {
      if typ, ok := typ.(*int); ok {
            return *typ
      }
      return typ

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 13265: nil pointer deref.

package p

func f() {
    var c chan chan chan int
    for ; ; <-<-<-c {
    }

package main

import "./q1"

func main() {
      x := 1
      y := q1.Deref(&x)
      if y != 1 {
            panic("y != 1")
      }

	case *types.Interface:
		return InterfaceTermSet(typ)
	default:
		return []*types.Term{types.NewTerm(false, typ)}, nil
	}
}

// Deref returns the type of the variable pointed to by t,
// if t's core type is a pointer; otherwise it returns t.
//
// Do not assume that Deref(T)==T implies T is not a pointer:
// consider "type T *T", for example.
//
// TODO(adonovan): ideally this would live in typesinternal, but that