Consider the following function:

```mathematica
f[arg_] := Print[Unevaluated[arg]];
Attributes[f] = HoldAll;
```

The purpose of the function is to print the arguments unevaluated. In particular, what's important to me is that a symbol that already has a value will be printed as the symbol and not the value. For example:

```mathematica
x = 1;
f[x];
```

The output is `x` as desired. But now I want to have the same behaviour with multiple arguments, either as a `List` or a `BlankSequence`. Here are my attempts:

With a `List`:

```mathematica
fList[args_] := Print[Unevaluated /@ args]; 
Attributes[fList] = HoldAll;
x = 1;
y = 1;
fList[{x, y}]
```

With a `BlankSequence`:

```mathematica
fBS[args__] := Print[Unevaluated /@ {args}];
Attributes[fBS] = HoldAll;
x = 1;
y = 1;
fBS[x, y]
```

In both cases the expected output is `{x, y}`, but what I actually get is `{Unevaluated[1], Unevaluated[1]}`! It seems that the `HoldAll` attribute doesn't actually do anything in these cases... Is there any way to solve this issue?

Thanks.

**Edit in response to comments:**

I understand that `f[{x,y}]` with the original `f` will work, if all I want to do is print the arguments. But what I wrote here is just a simple toy example. The actual function I want to use in my program does other things with the arguments, and needs to be able to access each argument's symbol individually.

Consider this (also toy) example instead:

```mathematica
g[arg_] := ToCharacterCode[ToString[Unevaluated[arg]]];
Attributes[g] = HoldAll;
x = 1;
y = 1;
```

The output of `g[x]` will be `{120}`. But the output of `g[{x, y}]` will be `{123, 120, 44, 32, 121, 125}` which is of course not what I want. I want a function that will return `{120, 121}`, i.e. the character codes of the letters `x` and `y`.

If I try for example:

```mathematica
gList[args_] := ToCharacterCode[ToString /@ Unevaluated[args]];
Attributes[gList] = HoldAll;
gList[{x, y}]
```

I get `{{49}, {49}}` which are the character codes of `1`, instead of `{{120}, {121}}` which is what I want. Is there any function that will return the desired result?