code: def reshape(
      x: paddle.Tensor,
      /,
      shape: Union[ivy.NativeShape, Sequence[int]],
      *,
      copy: Optional[bool] = None,
      order: Optional[str] = "C",
      allowzero: Optional[bool] = True,
      out: Optional[paddle.Tensor] = None,
  ) -> paddle.Tensor:
      if 0 in x.shape:
          if -1 in shape:
              shape = [
                  (
                      s
                      if s != -1
                      else math.prod(x.shape)
                      // math.prod([s for s in shape if s != -1])
                  )
                  for s in shape
              ]
          return paddle.empty(shape, dtype=x.dtype)
      if len(shape) == 0:
          out_scalar = True
          shape = [1]
      else:
          out_scalar = False
      if not allowzero:
          shape = [
              new_s if con else old_s
              for new_s, con, old_s in zip(
                  shape, paddle.to_tensor(shape) != 0, x.shape
              )
          ]
      if len(x.shape) == 0:
          x = paddle.reshape(x, shape=[1])
      if order == "F":
          ret = _reshape_fortran_paddle(x, shape)
          if out_scalar:
              return paddle_backend.squeeze(ret, axis=0)
  
          return ret
      ret = paddle.reshape(x, shape)
      if out_scalar:
          return paddle_backend.squeeze(ret, axis=0)
  
      return ret
  
imports: from numbers import Number
  from typing import Union, Optional, Tuple, List, Sequence, Iterable
  import math
  import paddle
  import ivy
  import ivy.functional.backends.paddle
  from ivy.func_wrapper import with_unsupported_device_and_dtypes, with_unsupported_dtypes, with_supported_dtypes
  from .None import backend_version
  from ...ivy.manipulation import _calculate_out_shape
label_desc: Use image node_id 6 for calling a global function with example usage: reshape(shape) and returns: ret, paddle, ret, paddle_backend, paddle_backend