}
  }];
}

def TF_Log1pOp : TF_Op<"Log1p", [Pure, TF_CwiseUnary, TF_SameOperandsAndResultTypeResolveRef]> {
  let summary = "Computes natural logarithm of (1 + x) element-wise.";

  let description = [{
I.e., \\(y = \log_e (1 + x)\\).

Example:

```python
x = tf.constant([0, 0.5, 1, 5])
tf.math.log1p(x) ==> [0., 0.4054651, 0.6931472, 1.7917595]
```
  }];

		{"J0", Func, 0},
		{"J1", Func, 0},
		{"Jn", Func, 0},
		{"Ldexp", Func, 0},
		{"Lgamma", Func, 0},
		{"Ln10", Const, 0},
		{"Ln2", Const, 0},
		{"Log", Func, 0},
		{"Log10", Func, 0},
		{"Log10E", Const, 0},
		{"Log1p", Func, 0},
		{"Log2", Func, 0},
		{"Log2E", Const, 0},
		{"Logb", Func, 0},
		{"Max", Func, 0},
		{"MaxFloat32", Const, 0},
		{"MaxFloat64", Const, 0},

        `tf.math.greater`, `tf.math.greater_equal`, `tf.math.igamma`,
        `tf.math.igammac`, `tf.math.invert_permutation`, `tf.math.less`,
        `tf.math.less_equal`, `tf.math.lgamma`, `tf.math.log`, `tf.math.log1p`,
        `tf.math.logical_and`, `tf.math.logical_not`, `tf.math.logical_or`,
        `tf.math.maximum`, `tf.math.minimum`, `tf.math.not_equal`,
        `tf.math.polygamma`, `tf.math.reciprocal`, `tf.math.rint`,

	// result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log16(c)]))
	for {
		n := v_0
		if v_1.Op != OpConst16 {
			break
		}
		c := auxIntToInt16(v_1.AuxInt)
		if !(isNonNegative(n) && isPowerOfTwo16(c)) {
			break
		}
		v.reset(OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
		v0.AuxInt = int64ToAuxInt(log16(c))
		v.AddArg2(n, v0)
		return true
	}