text: #!/usr/bin/python
  """
  Utility functions to work with cyclic patterns.
  """
  
  __lower_alpha = 'abcdefghijklmnopqrstuvwxyz'
  __upper_alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  __numeric = '0123456789'
  
  def pattern_create(length, charsets=None):
      """Generates a unique, nonrepeating pattern of a given length.
  
      length:
          the resulting pattern's length, in characters
  
      charsets: 
          if given, must be a tuple/list containing 3 strings. The pattern
          will be generated using the given sets.
  
      """
      if charsets is None:
          charsets = (__upper_alpha, __lower_alpha, __numeric)
      if length <= 0:
          return ''
  
      state = [0, 0, 0]
      output = []
      count = (length + 2) // 3
      while count > 0:
          output.append(charsets[0][state[0]] 
              + charsets[1][state[1]] 
              + charsets[2][state[2]])
          state[2] += 1
          if state[2] >= len(charsets[2]):
              state[2] = 0
              state[1] += 1
              if state[1] >= len(charsets[1]):
                  state[1] = 0
                  state[0] += 1
                  if state[0] >= len(charsets[0]):
                      state[0] = 0
                      # print 'WARNING: the sequence has started over.'
          count -= 1
      return ''.join(output)[:length]
  
  # Handy command-line usage
  if __name__ == '__main__':
      import sys
  
      op = sys.argv[1]
  
      if op == 'make':
          length = int(sys.argv[2])
          print pattern_create(length)
      elif op == 'find':
          value = sys.argv[2]
          max_len = int(sys.argv[3])
          print 'Value provided: %s' % value
  
          if len(value) == 8:
              print 'Considering the value to be a hex register data'
              value = value.upper()
              chars = [chr(int(value[0:2], 16)),
                  chr(int(value[2:4], 16)),
                  chr(int(value[4:6], 16)),
                  chr(int(value[6:8], 16))]
          elif len(value) == 4:
              print 'Considering the value to be a string'
              chars = value
          pat = pattern_create(max_len)
          pos = pat.find(''.join(chars))
          if pos == -1:
              chars = chars[::-1]
              pos = pat.find(''.join(chars))
              if pos == -1:
                  print 'Not found (tried both BE and LE)'
              else:
                  print 'Found (LE order) at offset %d' % pos
          else:
              print 'Found (BE order) at offset %d' % pos
  