docs: def _write_arg_read_code(builder, arg, args, name):
      """
      Writes the read code for the given argument, setting the
      arg.name variable to its read value.
  
      :param builder: The source code builder
      :param arg: The argument to write
      :param args: All the other arguments in TLObject same on_send.
                   This is required to determine the flags value
      :param name: The name of the argument. Defaults to "self.argname"
                   This argument is an option because it's required when
                   writing Vectors<>
      """
  
      if arg.generic_definition:
          return  # Do nothing, this only specifies a later type
  
      # The argument may be a flag, only write that flag was given!
      was_flag = False
      if arg.is_flag:
          # Treat 'true' flags as a special case, since they're true if
          # they're set, and nothing else needs to actually be read.
          if 'true' == arg.type:
              builder.writeln('{} = bool(flags & {})',
                              name, 1 << arg.flag_index)
              return
  
          was_flag = True
          builder.writeln('if flags & {}:', 1 << arg.flag_index)
          # Temporary disable .is_flag not to enter this if
          # again when calling the method recursively
          arg.is_flag = False
  
      if arg.is_vector:
          if arg.use_vector_id:
              # We have to read the vector's constructor ID
              builder.writeln("reader.read_int()")
  
          builder.writeln('{} = []', name)
          builder.writeln('for _ in range(reader.read_int()):')
          # Temporary disable .is_vector, not to enter this if again
          arg.is_vector = False
          _write_arg_read_code(builder, arg, args, name='_x')
          builder.writeln('{}.append(_x)', name)
          arg.is_vector = True
  
      elif arg.flag_indicator:
          # Read the flags, which will indicate what items we should read next
          builder.writeln('flags = reader.read_int()')
          builder.writeln()
  
      elif 'int' == arg.type:
          builder.writeln('{} = reader.read_int()', name)
  
      elif 'long' == arg.type:
          builder.writeln('{} = reader.read_long()', name)
  
      elif 'int128' == arg.type:
          builder.writeln('{} = reader.read_large_int(bits=128)', name)
  
      elif 'int256' == arg.type:
          builder.writeln('{} = reader.read_large_int(bits=256)', name)
  
      elif 'double' == arg.type:
          builder.writeln('{} = reader.read_double()', name)
  
      elif 'string' == arg.type:
          builder.writeln('{} = reader.tgread_string()', name)
  
      elif 'Bool' == arg.type:
          builder.writeln('{} = reader.tgread_bool()', name)
  
      elif 'true' == arg.type:
          # Arbitrary not-None value, don't actually read "true" flags
          builder.writeln('{} = True', name)
  
      elif 'bytes' == arg.type:
          builder.writeln('{} = reader.tgread_bytes()', name)
  
      elif 'date' == arg.type:  # Custom format
          builder.writeln('{} = reader.tgread_date()', name)
  
      else:
          # Else it may be a custom type
          if not arg.skip_constructor_id:
              builder.writeln('{} = reader.tgread_object()', name)
          else:
              # Import the correct type inline to avoid cyclic imports.
              # There may be better solutions so that we can just access
              # all the types before the files have been parsed, but I
              # don't know of any.
              sep_index = arg.type.find('.')
              if sep_index == -1:
                  ns, t = '.', arg.type
              else:
                  ns, t = '.' + arg.type[:sep_index], arg.type[sep_index+1:]
              class_name = snake_to_camel_case(t)
  
              # There would be no need to import the type if we're in the
              # file with the same namespace, but since it does no harm
              # and we don't have information about such thing in the
              # method we just ignore that case.
              builder.writeln('from {} import {}', ns, class_name)
              builder.writeln('{} = {}.from_reader(reader)',
                              name, class_name)
  
      # End vector and flag blocks if required (if we opened them before)
      if arg.is_vector:
          builder.end_block()
  
      if was_flag:
          builder.current_indent -= 1
          builder.writeln('else:')
          builder.writeln('{} = None', name)
          builder.current_indent -= 1
          # Restore .is_flag
          arg.is_flag = True