code: func (arguments Arguments) unpackTuple(v interface{}, marshalledValues []interface{}) error {
  	var (
  		value = reflect.ValueOf(v).Elem()
  		typ   = value.Type()
  		kind  = value.Kind()
  	)
  	if err := requireUnpackKind(value, typ, kind, arguments); err != nil {
  		return err
  	}
  
  	// If the interface is a struct, get of abi->struct_field mapping
  	var abi2struct map[string]string
  	if kind == reflect.Struct {
  		var (
  			argNames []string
  			err      error
  		)
  		for _, arg := range arguments.NonIndexed() {
  			argNames = append(argNames, arg.Name)
  		}
  		abi2struct, err = mapArgNamesToStructFields(argNames, value)
  		if err != nil {
  			return err
  		}
  	}
  	for i, arg := range arguments.NonIndexed() {
  		switch kind {
  		case reflect.Struct:
  			field := value.FieldByName(abi2struct[arg.Name])
  			if !field.IsValid() {
  				return fmt.Errorf("abi: field %s can't be found in the given value", arg.Name)
  			}
  			if err := unpack(&arg.Type, field.Addr().Interface(), marshalledValues[i]); err != nil {
  				return err
  			}
  		case reflect.Slice, reflect.Array:
  			if value.Len() < i {
  				return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(arguments), value.Len())
  			}
  			v := value.Index(i)
  			if err := requireAssignable(v, reflect.ValueOf(marshalledValues[i])); err != nil {
  				return err
  			}
  			if err := unpack(&arg.Type, v.Addr().Interface(), marshalledValues[i]); err != nil {
  				return err
  			}
  		default:
  			return fmt.Errorf("abi:[2] cannot unmarshal tuple in to %v", typ)
  		}
  	}
  	return nil
  
  }
docs: // unpackTuple unpacks ( hexdata -> go ) a batch of values.