cu = torch.jit.CompilationUnit('''
    def foo(x, y):
        return x.avd(y)
''')

RuntimeError:
unknown builtin op: aten::avd
Here are some suggestions:
	aten::svd
	aten::add
	aten::gcd
	aten::add_
	aten::abs
	aten::rand
	aten::std
	aten::mv
	aten::any
	aten::all
	aten::addr
	aten::ord
	aten::save
:

    def foo(x, y):
        return x.avd(y)
               ~~~~~ <--- HERE

RuntimeError:
Unknown builtin op: aten::avd.
Here are some suggestions:
	aten::svd
	aten::add
	aten::gcd
	aten::add_
	aten::abs
	aten::rand
	aten::std
	aten::mv
	aten::any
	aten::all
	aten::addr
	aten::ord
	aten::save

The original call is:

    def foo(x, y):
        return x.avd(y)
               ~~~~~ <--- HERE

cu = torch.jit.CompilationUnit('''
    def foo(x, y):
        return torch.add(x,y,x,y)
''')

RuntimeError:
arguments for call are not valid:

  for operator aten::add(Tensor self, Tensor other, *, Scalar alpha=<default>) -> Tensor:
  expected at most 2 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE


  for operator aten::add(Tensor self, Scalar other, Scalar alpha=<default>) -> Tensor:
  expected at most 3 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE


  for operator aten::add(Tensor self, Tensor other, *, Scalar alpha=<default>, Tensor out) -> Tensor:
  argument out not provided.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE

  for operator aten::add(string a, string b) -> string:
  Expected a value of type str for argument 'a' but found Tensor

      def foo(x, y):
          return torch.add(x,y,x,y)
                           ~ <--- HERE

  for operator aten::add(int[] a, int[] b) -> int[]:
  Expected a value of type List[int] for argument 'a' but found Tensor

      def foo(x, y):
          return torch.add(x,y,x,y)
                           ~ <--- HERE

  for operator aten::add(float[] a, float[] b) -> float[]:
  Expected a value of type List[float] for argument 'a' but found Tensor

      def foo(x, y):
          return torch.add(x,y,x,y)
                           ~ <--- HERE

  for operator aten::add(bool[] a, bool[] b) -> bool[]:
  Expected a value of type List[bool] for argument 'a' but found Tensor

      def foo(x, y):
          return torch.add(x,y,x,y)
                           ~ <--- HERE

  for operator aten::add(Tensor[] a, Tensor[] b) -> Tensor[]:
  Expected a value of type List[Tensor] for argument 'a' but found Tensor

      def foo(x, y):
          return torch.add(x,y,x,y)
                           ~ <--- HERE

  for operator aten::add(t[] a, t[] b) -> t[]:
  Could not match type Tensor to List[t] in argument 'a': Cannot match List[t] to Tensor

      def foo(x, y):
          return torch.add(x,y,x,y)
                           ~ <--- HERE

  for operator aten::add(int a, int b) -> int:
  expected at most 2 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE


  for operator aten::add(float a, float b) -> float:
  expected at most 2 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE


  for operator aten::add(int a, float b) -> float:
  expected at most 2 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE


  for operator aten::add(float a, int b) -> float:
  expected at most 2 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE


  for operator add(float a, Tensor b) -> Tensor:
  expected at most 2 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE


  for operator add(int a, Tensor b) -> Tensor:
  expected at most 2 arguments but found 4 positional arguments.

      def foo(x, y):
          return torch.add(x,y,x,y)
                 ~~~~~~~~~ <--- HERE

for call at:

    def foo(x, y):
        return torch.add(x,y,x,y)
               ~~~~~~~~~ <--- HERE

RuntimeError:
Arguments for call are not valid.
The following operator variants are available:

  aten::add(Tensor self, Tensor other, *, Scalar alpha=<default>) -> Tensor:
  Expected at most 2 arguments but found 4 positional arguments.

  aten::add(Tensor self, Scalar other, Scalar alpha=<default>) -> Tensor:
  Expected at most 3 arguments but found 4 positional arguments.

  aten::add(Tensor self, Tensor other, *, Scalar alpha=<default>, Tensor out) -> Tensor:
  Argument out not provided.

  aten::add(string a, string b) -> string:
  Expected a value of type str for argument 'a' but found Tensor.

  aten::add(int[] a, int[] b) -> int[]:
  Expected a value of type List[int] for argument 'a' but found Tensor.

  aten::add(float[] a, float[] b) -> float[]:
  Expected a value of type List[float] for argument 'a' but found Tensor.

  aten::add(bool[] a, bool[] b) -> bool[]:
  Expected a value of type List[bool] for argument 'a' but found Tensor.

  aten::add(Tensor[] a, Tensor[] b) -> Tensor[]:
  Expected a value of type List[Tensor] for argument 'a' but found Tensor.

  aten::add(t[] a, t[] b) -> t[]:
  Could not match type Tensor to List[t] in argument 'a': Cannot match List[t] to Tensor.

  aten::add(int a, int b) -> int:
  Expected at most 2 arguments but found 4 positional arguments.

  aten::add(float a, float b) -> float:
  Expected at most 2 arguments but found 4 positional arguments.

  aten::add(int a, float b) -> float:
  Expected at most 2 arguments but found 4 positional arguments.

  aten::add(float a, int b) -> float:
  Expected at most 2 arguments but found 4 positional arguments.

  add(float a, Tensor b) -> Tensor:
  Expected at most 2 arguments but found 4 positional arguments.

  add(int a, Tensor b) -> Tensor:
  Expected at most 2 arguments but found 4 positional arguments.

The original call is:

    def foo(x, y):
        return torch.add(x,y,x,y)
               ~~~~~~~~~ <--- HERE