code: def compute_conv1d_instructions(
      self, in_W, in_C, kernel_size=3, stride=1, pad=0
  ):
      # Current limitations
      assert pad == 0
  
      if kernel_size >= stride:
          min_W = (
              math.ceil(kernel_size / stride) - 1
          ) * stride + kernel_size
      else:
          min_W = (
              math.ceil(stride / kernel_size) - 1
          ) * stride + kernel_size
  
      # if the standard min_W is smaller than the in_W, then use unscaled
      if min_W > in_W:
          min_W = in_W
  
      min_oW = int((min_W - kernel_size) // stride + 1)
  
      out_W = int((in_W - kernel_size) // stride + 1)
      scaled_W = (out_W - 1) * stride + kernel_size
  
      if scaled_W < in_W:
          min_W += 1
  
      windows_bin = [
          [0 for _ in range(kernel_size)] for _ in range(min_W)
      ]
  
      for i_ow in range(min_oW):
          for i_fw in range(kernel_size):
              index_data = i_ow * stride + i_fw - pad
              windows_bin[index_data][i_fw] = 1
  
      windows_int = []
  
      for i in range(min_W):
          windows_int.append(
              int("".join(str(p) for p in reversed(windows_bin[i])), 2)
          )
  
      return (min_W, windows_int)
  
imports: import math
  import os
  import re
  from bisect import bisect_left
  from collections.abc import Iterable
  import numpy
  from hls4ml.backends.backend import Backend
  from hls4ml.model.attributes import ChoiceAttribute, ConfigurableAttribute, TypeAttribute
  from hls4ml.model.layers import GRU, LSTM, Activation, BatchNormalization, Conv1D, Conv2D, Dense, Dot, Embedding, GarNet, GarNetStack, GlobalPooling1D, GlobalPooling2D, Pooling1D, Pooling2D, SeparableConv1D, SeparableConv2D, SimpleRNN, Softmax
  from hls4ml.model.optimizer import model_optimizer
  from hls4ml.model.types import ExponentPrecisionType, FixedPrecisionType, IntegerPrecisionType, RoundingMode, SaturationMode, XnorPrecisionType
  from hls4ml.writer import get_writer
label_desc: Use image node_id 17 for calling the FPGABackend obj's underlying member method code with example usage: obj.compute_conv1d_instructions(in_W, in_C, kernel_size, stride, pad) and returns: min_W,  windows_int