text: package stdlib
  
  import (
  	"fmt"
  	"math/big"
  
  	"github.com/zclconf/go-cty/cty"
  	"github.com/zclconf/go-cty/cty/function"
  )
  
  var AbsoluteFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "num",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
  		return args[0].Absolute(), nil
  	},
  })
  
  var AddFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		// big.Float.Add can panic if the input values are opposing infinities,
  		// so we must catch that here in order to remain within
  		// the cty Function abstraction.
  		defer func() {
  			if r := recover(); r != nil {
  				if _, ok := r.(big.ErrNaN); ok {
  					ret = cty.NilVal
  					err = fmt.Errorf("can't compute sum of opposing infinities")
  				} else {
  					// not a panic we recognize
  					panic(r)
  				}
  			}
  		}()
  		return args[0].Add(args[1]), nil
  	},
  })
  
  var SubtractFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		// big.Float.Sub can panic if the input values are infinities,
  		// so we must catch that here in order to remain within
  		// the cty Function abstraction.
  		defer func() {
  			if r := recover(); r != nil {
  				if _, ok := r.(big.ErrNaN); ok {
  					ret = cty.NilVal
  					err = fmt.Errorf("can't subtract infinity from itself")
  				} else {
  					// not a panic we recognize
  					panic(r)
  				}
  			}
  		}()
  		return args[0].Subtract(args[1]), nil
  	},
  })
  
  var MultiplyFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		// big.Float.Mul can panic if the input values are both zero or both
  		// infinity, so we must catch that here in order to remain within
  		// the cty Function abstraction.
  		defer func() {
  			if r := recover(); r != nil {
  				if _, ok := r.(big.ErrNaN); ok {
  					ret = cty.NilVal
  					err = fmt.Errorf("can't multiply zero by infinity")
  				} else {
  					// not a panic we recognize
  					panic(r)
  				}
  			}
  		}()
  
  		return args[0].Multiply(args[1]), nil
  	},
  })
  
  var DivideFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		// big.Float.Quo can panic if the input values are both zero or both
  		// infinity, so we must catch that here in order to remain within
  		// the cty Function abstraction.
  		defer func() {
  			if r := recover(); r != nil {
  				if _, ok := r.(big.ErrNaN); ok {
  					ret = cty.NilVal
  					err = fmt.Errorf("can't divide zero by zero or infinity by infinity")
  				} else {
  					// not a panic we recognize
  					panic(r)
  				}
  			}
  		}()
  
  		return args[0].Divide(args[1]), nil
  	},
  })
  
  var ModuloFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		// big.Float.Mul can panic if the input values are both zero or both
  		// infinity, so we must catch that here in order to remain within
  		// the cty Function abstraction.
  		defer func() {
  			if r := recover(); r != nil {
  				if _, ok := r.(big.ErrNaN); ok {
  					ret = cty.NilVal
  					err = fmt.Errorf("can't use modulo with zero and infinity")
  				} else {
  					// not a panic we recognize
  					panic(r)
  				}
  			}
  		}()
  
  		return args[0].Modulo(args[1]), nil
  	},
  })
  
  var GreaterThanFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Bool),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		return args[0].GreaterThan(args[1]), nil
  	},
  })
  
  var GreaterThanOrEqualToFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Bool),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		return args[0].GreaterThanOrEqualTo(args[1]), nil
  	},
  })
  
  var LessThanFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Bool),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		return args[0].LessThan(args[1]), nil
  	},
  })
  
  var LessThanOrEqualToFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "a",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  		{
  			Name:             "b",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Bool),
  	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  		return args[0].LessThanOrEqualTo(args[1]), nil
  	},
  })
  
  var NegateFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "num",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
  		return args[0].Negate(), nil
  	},
  })
  
  var MinFunc = function.New(&function.Spec{
  	Params: []function.Parameter{},
  	VarParam: &function.Parameter{
  		Name:             "numbers",
  		Type:             cty.Number,
  		AllowDynamicType: true,
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
  		if len(args) == 0 {
  			return cty.NilVal, fmt.Errorf("must pass at least one number")
  		}
  
  		min := cty.PositiveInfinity
  		for _, num := range args {
  			if num.LessThan(min).True() {
  				min = num
  			}
  		}
  
  		return min, nil
  	},
  })
  
  var MaxFunc = function.New(&function.Spec{
  	Params: []function.Parameter{},
  	VarParam: &function.Parameter{
  		Name:             "numbers",
  		Type:             cty.Number,
  		AllowDynamicType: true,
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
  		if len(args) == 0 {
  			return cty.NilVal, fmt.Errorf("must pass at least one number")
  		}
  
  		max := cty.NegativeInfinity
  		for _, num := range args {
  			if num.GreaterThan(max).True() {
  				max = num
  			}
  		}
  
  		return max, nil
  	},
  })
  
  var IntFunc = function.New(&function.Spec{
  	Params: []function.Parameter{
  		{
  			Name:             "num",
  			Type:             cty.Number,
  			AllowDynamicType: true,
  		},
  	},
  	Type: function.StaticReturnType(cty.Number),
  	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
  		bf := args[0].AsBigFloat()
  		if bf.IsInt() {
  			return args[0], nil
  		}
  		bi, _ := bf.Int(nil)
  		bf = (&big.Float{}).SetInt(bi)
  		return cty.NumberVal(bf), nil
  	},
  })
  
  // Absolute returns the magnitude of the given number, without its sign.
  // That is, it turns negative values into positive values.
  func Absolute(num cty.Value) (cty.Value, error) {
  	return AbsoluteFunc.Call([]cty.Value{num})
  }
  
  // Add returns the sum of the two given numbers.
  func Add(a cty.Value, b cty.Value) (cty.Value, error) {
  	return AddFunc.Call([]cty.Value{a, b})
  }
  
  // Subtract returns the difference between the two given numbers.
  func Subtract(a cty.Value, b cty.Value) (cty.Value, error) {
  	return SubtractFunc.Call([]cty.Value{a, b})
  }
  
  // Multiply returns the product of the two given numbers.
  func Multiply(a cty.Value, b cty.Value) (cty.Value, error) {
  	return MultiplyFunc.Call([]cty.Value{a, b})
  }
  
  // Divide returns a divided by b, where both a and b are numbers.
  func Divide(a cty.Value, b cty.Value) (cty.Value, error) {
  	return DivideFunc.Call([]cty.Value{a, b})
  }
  
  // Negate returns the given number multipled by -1.
  func Negate(num cty.Value) (cty.Value, error) {
  	return NegateFunc.Call([]cty.Value{num})
  }
  
  // LessThan returns true if a is less than b.
  func LessThan(a cty.Value, b cty.Value) (cty.Value, error) {
  	return LessThanFunc.Call([]cty.Value{a, b})
  }
  
  // LessThanOrEqualTo returns true if a is less than b.
  func LessThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
  	return LessThanOrEqualToFunc.Call([]cty.Value{a, b})
  }
  
  // GreaterThan returns true if a is less than b.
  func GreaterThan(a cty.Value, b cty.Value) (cty.Value, error) {
  	return GreaterThanFunc.Call([]cty.Value{a, b})
  }
  
  // GreaterThanOrEqualTo returns true if a is less than b.
  func GreaterThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
  	return GreaterThanOrEqualToFunc.Call([]cty.Value{a, b})
  }
  
  // Modulo returns the remainder of a divided by b under integer division,
  // where both a and b are numbers.
  func Modulo(a cty.Value, b cty.Value) (cty.Value, error) {
  	return ModuloFunc.Call([]cty.Value{a, b})
  }
  
  // Min returns the minimum number from the given numbers.
  func Min(numbers ...cty.Value) (cty.Value, error) {
  	return MinFunc.Call(numbers)
  }
  
  // Max returns the maximum number from the given numbers.
  func Max(numbers ...cty.Value) (cty.Value, error) {
  	return MaxFunc.Call(numbers)
  }
  
  // Int removes the fractional component of the given number returning an
  // integer representing the whole number component, rounding towards zero.
  // For example, -1.5 becomes -1.
  //
  // If an infinity is passed to Int, an error is returned.
  func Int(num cty.Value) (cty.Value, error) {
  	if num == cty.PositiveInfinity || num == cty.NegativeInfinity {
  		return cty.NilVal, fmt.Errorf("can't truncate infinity to an integer")
  	}
  	return IntFunc.Call([]cty.Value{num})
  }
  