code: def gen_forward():
      kernels = [3, 5, 7, 15, 31, 63, 127, 255]
      seqs = [
          32 * x
          for x in [
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              14,
              15,
              16,
          ]
      ]
  
      head = """
  /**
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */
  
  #include "lightconv_cuda.cuh"
  
  std::vector<at::Tensor> lightconv_cuda_forward(at::Tensor input, at::Tensor filters, int padding_l) {
  
      at::DeviceGuard g(input.device());
      const auto minibatch = input.size(0);
      const auto numFeatures = input.size(1);
      const auto sequenceLength = input.size(2);
  
      const auto numHeads = filters.size(0);
      const auto filterSize = filters.size(1);
  
      const auto numFiltersInBlock = numFeatures / numHeads;
  
      const dim3 blocks(minibatch, numFeatures);
  
      auto output = at::zeros_like(input);
      auto stream = at::cuda::getCurrentCUDAStream();
  """
  
      sequence_if = """
      if (sequenceLength <= {seq}) {{
          switch(filterSize) {{
  """
  
      case_k = """
              case {k}:
  """
  
      main_block = """
                  if (padding_l == {pad}) {{
                      AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.scalar_type(), "lightconv_forward", ([&] {{
                          lightconv_forward_kernel<{k}, {b_size}, {pad}, scalar_t>
                          <<<blocks, {b_size}, 0, stream>>>(
                                  input.data<scalar_t>(),
                                  filters.data<scalar_t>(),
                                  minibatch,
                                  sequenceLength,
                                  numFeatures,
                                  numFiltersInBlock,
                                  output.data<scalar_t>());
                      }}));
                  }} else
  """
  
      bad_padding = """
                  {
                      std::cout << "WARNING: Unsupported padding size - skipping forward pass" << std::endl;
                  }
                  break;
  """
  
      bad_filter = """
              default:
                  std::cout << "WARNING: Unsupported filter length passed - skipping forward pass" << std::endl;
          }
  """
  
      con_else = """
      } else
  """
  
      final_else = """
      {
          switch(filterSize) {
  """
  
      final_return = """
      }
  
      return {output};
  }
  """
  
      with open("lightconv_cuda_forward.cu", "w") as forward:
          forward.write(head)
          for seq in seqs:
              forward.write(sequence_if.format(seq=seq))
              for k in kernels:
                  forward.write(case_k.format(k=k))
                  for pad in [k // 2, k - 1]:
                      forward.write(
                          main_block.format(k=k, b_size=seq, pad=pad)
                      )
                  forward.write(bad_padding)
              forward.write(bad_filter)
              forward.write(con_else)
  
          forward.write(final_else)
          for k in kernels:
              forward.write(case_k.format(k=k))
              for pad in [k // 2, k - 1]:
                  forward.write(
                      main_block.format(k=k, b_size=seq, pad=pad)
                  )
              forward.write(bad_padding)
          forward.write(bad_filter)
          forward.write(final_return)
  
label_desc: Use image node_id 1 for calling a global function with example usage: gen_forward() without return types