// Abs returns the absolute value of x.
191347
func Abs(x int64) uint64 {
	m := x >> 63
	return uint64((x ^ m) - m)
}
1034774
func (m Mat4) Abs() Mat4 {
	return Mat4{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5]), Abs(m[6]), Abs(m[7]), Abs(m[8]), Abs(m[9]), Abs(m[10]), Abs(m[11]), Abs(m[12]), Abs(m[13]), Abs(m[14]), Abs(m[15])}
}
1208631
func AbsPath(base *string) error {
	v, err := filepath.Abs(*base)
	if err != nil {
		return errors.Annotate(err, "unable to resolve absolute path").
			InternalReason("base(%q)", *base).Err()
	}
	*base = v
	return nil
}
672513
@Override
    public <N extends Number> Expression<N> abs(Expression<N> arg0)
    {
        // TODO Auto-generated method stub
        return null;
    }
651492
func (as ArraySpec) Abs() Input {
	return as.proc(func(i Input) Input {
		return i.Abs()
	})
}
291369
func MustAbs(dir string) string {
	absDir, err := filepath.Abs(dir)
	if err != nil {
		panic(fmt.Sprintf("Failed to get absolute path of a directory %q: %v\n", dir, err))
	}
	return filepath.Clean(absDir)
}
1165234
func (i *ignore) Absolute(path string, isdir bool) Match {
	// does the file share the same directory as this ignore file?
	if !strings.HasPrefix(path, i._base) {
		return nil
	}

	// extract the relative path of this file
	_prefix := len(i._base) + 1
	_rel := string(path[_prefix:])
	return i.Relative(_rel, isdir)
}
684079
func NewBitwiseXor(Variable node.Node, Expression node.Node) *BitwiseXor {
	return &BitwiseXor{
		FreeFloating: nil,
		Variable:     Variable,
		Expression:   Expression,
	}
}
278541
func CopyAbs(z, x *decimal.Big) *decimal.Big {
	return z.CopySign(x, pos)
}
283970
func PercentValue(value, sum float64) (s string) {
	value *= 100 / sum
	s = AbsoluteValue(value, sum) + "% "
	return
}
1222936
func makeAbsolute(inputFilePath, outputFilePath string) (string, string, error) {
	inputFilePath, err := filepath.Abs(inputFilePath)
	if err == nil {
		outputFilePath, err = filepath.Abs(outputFilePath)
	}

	return inputFilePath, outputFilePath, err
}
855776
func AbsoluteValue(value, sum float64) (s string) {
	fv := math.Abs(value)
	switch {
	case fv < 0.01:
		s = fmt.Sprintf(" %g ", value)
	case fv < 0.1:
		s = fmt.Sprintf(" %.2f ", value)
	case fv < 1:
		s = fmt.Sprintf(" %.1f ", value)
	case fv < 100000:
		s = fmt.Sprintf(" %.0f ", value)
	default:
		s = fmt.Sprintf(" %g ", value)
	}
	return
}
1231730
func (v LocalValue) Absolute(m ModuleInstance) AbsLocalValue {
	return AbsLocalValue{
		Module:     m,
		LocalValue: v,
	}
}
746106
func (sb *StatsdBuffer) Absolute(stat string, value int64) error {
	sb.eventChannel <- &event.Absolute{Name: stat, Values: []int64{value}}
	return nil
}
985672
func (r *Request) AbsPath(segments ...string) *Request {
	if r.err != nil {
		return r
	}
	if len(segments) == 1 {
		// preserve any trailing slashes for legacy behavior
		r.path = segments[0]
	} else {
		r.path = path.Join(segments...)
	}
	return r
}
892609
func isAlphanum(c int) bool {
	return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
		(c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c == '\\' ||
		c > 126)
}
120423
func Abstimesend(db XODB, v0 pgtypes.Abstime) ([]byte, error) {
	var err error

	// sql query
	const sqlstr = `SELECT pg_catalog.abstimesend($1)`

	// run query
	var ret []byte
	XOLog(sqlstr, v0)
	err = db.QueryRow(sqlstr, v0).Scan(&ret)
	if err != nil {
		return nil, err
	}

	return ret, nil
}