[Question]
  [
# Problem
given input `a,b,c`
where `a,b,c` are positive even integers
and `a > b > c`
Make a box of any allowed character with dimensions `a x a`
Center a box of a different allowed character with dimensions `b x b` within the previous
Center a box of another different allowed character with dimensions `c x c` within the previous
Allowed Characters are ASCII characters are in `[a-zA-z0-9!@#$%^&*()+,./<>?:";=_-+]`
Input `a=6, b=4, c=2`
```
######
#****#
#*@@*#
#*@@*#
#****#
######
```
Input `a=8, b=6, c=2`
```
########
#******#
#******#
#**@@**#
#**@@**#
#******#
#******#
########
```
Input `a=12, b=6, c=2`
```
############
############
############
###******###
###******###
###**@@**###
###**@@**###
###******###
###******###
############
############
############
```
# Rules
* **Shortest code wins**
* Remember that you can choose which char to print within the range given
* Trailing newlines accepted
* Trailing whitespace accepted
* functions may return string with newlines, string array, or print it
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 14 bytes
```
Ｆ#*@ＵＯ÷Ｎ²ι‖Ｃ←↑
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBQ0lZy0FJk0sBCPyTcvLz0jVcMssyU1I1PPMKSkv8SnOTUos0NHUUjIA4U9OaKyg1LSc1ucQ5v6BSwyq0QEfByic1rUTT@v9/QyMFMwWj/7pl/3WLcwA "Charcoal – Try It Online") Link is to verbose version of code.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ 19 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-1 byte using the quick ``` to avoid a link, as suggested by Erik the Outgolfer.
```
H»þ`€Ḣ>Ð€HSUṚm€0m0Y
```
A full program taking a list `[a,b,c]` printing the boxes using `a:2 b:1 c:0`  
... in fact, as is, it will work for up to **10** boxes, where the innermost box is `0` ([for example](https://tio.run/##y0rNyan8/9/j0O7D@xIeNa15uGOR3eEJQIZHcOjDnbNygSyDXIPI////Rxtb6Bib6Rib6BhZ6BiZ6RgZ6Ria6Bga6JjpmMQCAA "Jelly – Try It Online")).
**[Try it online!](https://tio.run/##y0rNyan8/9/j0O7D@xIeNa15uGOR3eEJQIZHcOjDnbNygSyDXIPI////Rxsa6ZjpGMUCAA "Jelly – Try It Online")**
### How?
```
H»þ`€Ḣ>Ð€HSUṚm€0m0Y - Main link: list of boxes, B = [a, b, c]
H                   - halve B = [a/2, b/2, c/2]
    €               - for €ach:
   `                -   repeat left argument as the right argument of the dyadic operation:
  þ                 -     outer product with the dyadic operation:
 »                  -       maximum
                    - ... Note: implicit range building causes this to yield
                    -       [[max(1,1),max(1,2),...,max(1,n)],
                    -        [max(2,1),max(2,2),...,max(2,n)],
                    -        ...
                    -        [max(n,1),max(n,2),...,max(n,n)]]
                    -       for n in [a/2,b/2,c/2]
     Ḣ              - head (we only really want n=a/2 - an enumeration of a quadrant)
         H          - halve B = [a/2, b/2, c/2]
       Ð€           - map across right with dyadic operation:
      >             -   is greater than?
                    - ...this yields three copies of the lower-right quadrant
                    -    with 0 if the location is within each box and 1 if not
          S         - sum ...yielding one with 0 for the innermost box, 1 for the next, ...
           U        - upend (reverse each) ...making it the lower-left
            Ṛ       - reverse ...making it the upper-right
             m€0    - reflect €ach row (mod-index, m, with right argument 0 reflects)
                m0  - reflect the rows ...now we have the whole thing with integers
                  Y - join with newlines ...making a mixed list of integers and characters
                    - implicit print - the representation of a mixed list is "smashed"
```
[Answer]
# Python 2, ~~107~~ 103 bytes
```
a,b,c=input()
r=range(1-a,a,2)
for y in r:
 s=''
 for x in r:m=max(x,y,-x,-y);s+=`(m>c)+(m>b)`
 print s
```
Full program, prints boxes with `a=2`,`b=1`,`c=0`
Slightly worse answer, with list comprehension (104 bytes):
```
a,b,c=input()
r=range(1-a,a,2)
for y in r:print''.join(`(m>c)+(m>b)`for x in r for m in[max(x,y,-x,-y)])
```
[Answer]
# C#, ~~274~~ 232 bytes
```
using System.Linq;(a,b,c)=>{var r=new string[a].Select(l=>new string('#',a)).ToArray();for(int i=0,j,m=(a-b)/2,n=(a-c)/2;i<b;++i)for(j=0;j<b;)r[i+m]=r[i+m].Remove(j+m,1).Insert(j+++m,i+m>=n&i+m<n+c&j+m>n&j+m<=n+c?"@":"*");return r;}
```
Terrible even for C# so can definitely be golfed but my mind has gone blank. 
Full/Formatted version:
```
using System;
using System.Linq;
class P
{
    static void Main()
    {
        Func<int, int, int, string[]> f = (a,b,c) =>
        {
            var r = new string[a].Select(l => new string('#', a)).ToArray();
            for (int i = 0, j, m = (a - b) / 2, n = (a - c) / 2; i < b; ++i)
                for (j = 0; j < b;)
                    r[i + m] = r[i + m].Remove(j + m, 1).Insert(j++ + m,
                        i + m >= n & i + m < n + c &
                        j + m > n & j + m <= n + c ? "@" : "*");
            return r;
        };
        Console.WriteLine(string.Join("\n", f(6,4,2)) + "\n");
        Console.WriteLine(string.Join("\n", f(8,6,2)) + "\n");
        Console.WriteLine(string.Join("\n", f(12,6,2)) + "\n");
        Console.ReadLine();
    }
}
```
[Answer]
# [Haskell](https://www.haskell.org/), 126 bytes
```
f a b c=r[r["#*@"!!(v c+v b)|x<-[1..d a],let v k|x>a#k&&y>a#k=1|2>1=0]|y<-[1..d a]]where r x=x++reverse x;d=(`div`2);x#y=d$x-y
```
[Try it online!](https://tio.run/##RcpNC4IwAAbgv/L6gWimpEQXm/QD6tRRJKebKH4g09aE/fdFp07P5enoOvBxNKYFRY2GiEIUtnO42ZblSzShRB1odY2KJI4ZaHkc@QaJQaucOoPn7T9IotM8IadS7/9ZfjouOAQUUWEouORi5VAZI37FelmlQaacnTBXRbuZaD@DYKLL44XlvT03cZ/hosUFZ6TmCw "Haskell – Try It Online")
[Answer]
# JavaScript (ES6), ~~174~~ ~~170~~ 147 bytes
```
a=>b=>c=>(d=("#"[r="repeat"](a)+`
`)[r](f=a/2-b/2))+(e=((g="#"[r](f))+"*"[r](b)+g+`
`)[r](h=b/2-c/2))+(g+(i="*"[r](h))+"@"[r](c)+i+g+`
`)[r](c)+e+d
```
---
## Try it
```
fn=
a=>b=>c=>(d=("#"[r="repeat"](a)+`
`)[r](f=a/2-b/2))+(e=((g="#"[r](f))+"*"[r](b)+g+`
`)[r](h=b/2-c/2))+(g+(i="*"[r](h))+"@"[r](c)+i+g+`
`)[r](c)+e+d
oninput=_=>+x.value>+y.value&&+y.value>+z.value&&(o.innerText=fn(+x.value)(+y.value)(+z.value))
o.innerText=fn(x.value=12)(y.value=6)(z.value=2)
```
```
label,input{font-family:sans-serif;}
input{margin:0 5px 0 0;width:50px;}
```
```
<label for=x>a: </label><input id=x min=6 type=number step=2><label for=y>b: </label><input id=y min=4 type=number step=2><label for=z>c: </label><input id=z min=2 type=number step=2><pre id=o>
```
---
## Explanation
```
a=>b=>c=>            :Anonymous function taking the 3 integers as input via parameters a, b & c
(d=...)              :Assign to variable d...
("#"[r="repeat"](a)  :  # repeated a times, with the repeat method aliased to variable r in the process.
+`\n`)               :  Append a literal newline.
[r](f=a/2-b/2)       :  Repeat the resulting string a/2-b/2 times, assigning the result of that calculation to variable f.
+                    :Append.
(e=...)              :Assign to variable e...
(g=...)              :  Assign to variable g...
"#"[r](f)            :    # repeated f times.
+"*"[r](b)           :  Append * repeated b times.
+g+`\n`)             :  Append g and a literal newline.
[r](h=b/2-c/2)       :  Repeat the resulting string b/2-c/2 times, assigning the result of that calculation to variable h.
+(...)               :Append ...
g+                   :  g
(i=...)              :  Assign to variable i...
"*"[r](h)            :    * repeated h times.
+"@"[r](c)           :  @ repeated c times
+i+g+`\n`)           :  Append i, g and a literal newline.
[r](c)               :...repeated c times.
+e+d                 :Append e and d.
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~70, 44~~, 42 bytes
```
Àé#@aÄÀG@b|{r*ÀG@c|{r@òjdòÍ.“.
ç./æ$pYHP
```
[Try it online!](https://tio.run/##K/v//3DD4ZXKDomHWw43uDsk1YhVF2mBWMkglsPhTVkphzcd7tU7NFmP6/ByPf3Dy1QKIj0C/v//b2j23@y/CQA "V – Try It Online")
~~This is hideous. Eww.~~ Much better. Still not the shortest, but at least *somewhat* golfy.
Saved two bytes thanks to @nmjmcman101!
Hexdump:
```
00000000: c0e9 2340 61c4 c047 4062 7c16 7b72 2ac0  ..#@a..G@b|.{r*.
00000010: 4740 637c 167b 7240 f26a 64f2 cd2e 932e  G@c|.{[[email protected]](/cdn-cgi/l/email-protection).....
00000020: 0ae7 2e2f e624 7059 4850                 .../.$pYHP
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 97 bytes
```
x,y;f(a,b,c){for(y=1-a;y<a;y+=2,puts(""))for(x=1-a;x<a;x+=2)printf(x/c|y/c?x/b|y/b?"#":"*":"@");}
```
[Try it online!](https://tio.run/##HczBCsIwEATQf1kvu7olNAcPxtL@SrIQ6cFaagsbtN8etx6GgXkw0jxEalUuIWPkxEKf/FqwdG0TQ7lbLp3neVvfCEB0mP5NzdSM5mWc1ozq5Fuc9OqSderhBDc4WwagsNdnHCe0b2w9X9kf0w8 "C (gcc) – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~26~~ ~~23~~ ~~22~~ ~~20~~ 18 bytes
```
2/t:<sPtPh!Vt!2$X>
```
Input is a column vector `[a; b; c]`. Output uses characters `2`, `1`, `0`.
[**Try it online!**](https://tio.run/##y00syfn/30i/xMqmOKAkIEMxrETRSCXC7v//aEMjawUzawWjWAA)
As an aside, it works for up to ten boxes, not just three. Here's an [example with five boxes](https://tio.run/##y00syfn/30i/xMqmOKAkIEMxrETRSCXC7v//aGMDawUjIDY0slYwAzJjAQ).
[Answer]
# Mathematica, 49 bytes
```
Print@@@Fold[#~CenterArray~{#2,#2}+1&,{{}},{##}]&
```
Takes input `[c, b, a]`. The output is `a=1, b=2, c=3`.
### How?
```
Print@@@Fold[#~CenterArray~{#2,#2}+1&,{{}},{##}]&
                                                &  (* Function *)
        Fold[                        ,{{}},{##}]   (* Begin with an empty 2D array.
                                                      iterate through the input: *)
                                    &              (* Function *)
             #~CenterArray~{#2,#2}                 (* Create a 0-filled array, size
                                                      (input)x(input), with the array
                                                      from the previous iteration
                                                      in the center *)
                                  +1               (* Add one *)
Print@@@                                           (* Print the result *)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-h`](https://codegolf.meta.stackexchange.com/a/14339/), 19 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Takes input in reverse (`c,b,a`) and outputs an array of lines using `=` for the outer box, `!` for the middle one and `-` for the inner one.
```
Æç-
4Æ=Õû¦gXz)NÅgXz
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWg&code=xuctCjTGPdX7pmdYeilOxWdYeg&input=MiA2IDEyCi1S)
```
Æç-\n4Æ=Õû¦gXz)NÅgXz     :Implicit input of integers U=c, V=b & W=a
Æ                        :Map the range [0,U)
 ç-                      :  Repeat "-" U times
   \n                    :Reassign to U
     4Æ                  :Map each X in the range [0,4)
       =                 :  Reassign to U ...
        Õ                :  Transpose U
         û               :  Centre pad each element with (1) to length (2)
          ¦              :    "!=" (1)
           g             :    Get character at index (1)
            Xz           :    X floor divided by 2 (1)
               )         :    End index (1)
                N        :    Array of all inputs, i.e. [U,V,W] (2)
                 Å       :    Slice off the first element (2)
                  gXz    :    As above (2)
                         :Implicit output of last element of resulting array
```
[Answer]
# PHP>=7.1, 180 bytes
In this case i hate that variables begin with a `$` in PHP
```
for([,$x,$y,$z]=$argv;$i<$x*$x;$p=$r%$x)echo XYZ[($o<($l=$x-$a=($x-$y)/2)&$o>($k=$a-1)&$p>$k&$p<$l)+($o>($m=$k+$b=($y-$z)/2)&$o<($n=$l-$b)&$p>$m&$p<$n)],($o=++$i%$x)?"":"\n".!++$r;
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/1e4347e37d478798af08eaf11bb09c8ba6500961)
[Answer]
# Mathematica, 173 bytes
```
(d=((a=#1)-(b=#2))/2;e=(b-(c=#3))/2;z=1+d;x=a-d;h=Table["*",a,a];h[[z;;x,z;;x]]=h[[z;;x,z;;x]]/.{"*"->"#"};h[[z+e;;x-e,z+e;;x-e]]=h[[z+e;;x-e,z+e;;x-e]]/.{"#"->"@"};Grid@h)&
```
**input**
> 
> [12,6,2]
> 
> 
> 
[Answer]
# [Python 2](https://docs.python.org/2/), 87 bytes
```
a,_,_=t=input();r=~a
exec"r+=2;print sum(10**x/9*10**((a-x)/2)*(r*r<x*x)for x in t);"*a
```
[Try it online!](https://tio.run/##FcXBCoMwDADQ@76ieEqyiprDQLp@i5ThsIfVEiNkl/16h@/y6le3vXBryS9@iRpzqacCBom/dFttfXVyjxyq5KLuOD8wjUQ2zHQNkHrDgZFASJ5Ghu9dnLlcnGLoKLXGo394/gM "Python 2 – Try It Online")
Arithmetically computes the numbers to print by adding numbers of the form `111100`. There's a lot of ugliness, probably room for improvement.
[Answer]
# JavaScript (ES6), 112
Anonymous function returning a multi line string. Characters 0,1,2
```
(a,b,c)=>eval("for(o='',i=-a;i<a;o+=`\n`,i+=2)for(j=-a;j<a;j+=2)o+=(i>=c|i<-c|j>=c|j<-c)+(i>=b|i<-b|j>=b|j<-b)")
```
*Less golfed*
```
(a,b,c)=>{
  for(o='',i=-a;i<a;o+=`\n`,i+=2)
    for(j=-a;j<a;j+=2)
      o+=(i>=c|i<-c|j>=c|j<-c)+(i>=b|i<-b|j>=b|j<-b)
  return o
}  
```
```
var F=
(a,b,c)=>eval("for(o='',i=-a;i<a;o+=`\n`,i+=2)for(j=-a;j<a;j+=2)o+=(i>=c|i<-c|j>=c|j<-c)+(i>=b|i<-b|j>=b|j<-b)")
function update()
{
  var [a,b,c]=I.value.match(/\d+/g)
  O.textContent=F(a,b,c)
}
update()
  
```
```
a,b,c <input id=I value='10 6 2' oninput='update()'>
<pre id=O></pre>
```
[Answer]
# PHP >= 5.6, 121 bytes
```
for($r=A;$p?:$p=($z=$argv[++$i])**2;)$r[((--$p/$z|0)+$o=($w=$w?:$z)-$z>>1)*$w+$p%$z+$o]=_BCD[$i];echo chunk_split($r,$w);
```
Run with `-nr` or [test it online](http://sandbox.onlinephpfunctions.com/code/253363638e55ecca2f2f6c7401b6fbea672b06ac).
Combined loops again ... I love them!
**breakdown**
```
for($r=A;                           # initialize $r (result) to string
    $p?:$p=($z=$argv[++$i])**2;)    # loop $z through arguments, loop $p from $z**2-1 to 0
    $r[((--$p/$z|0)+$o=
        ($w=$w?:$z)                     # set $w (total width) to first argument
        -$z>>1)*$w+$p%$z+$o]            # calculate position: (y+offset)*$w+x+offset
        =_BCD[$i];                      # paint allowed character (depending on $i)
echo chunk_split($r,$w);            # insert newline every $w characters and print
```
[Answer]
# Java 10, ~~265~~ ~~252~~ ~~218~~ ~~181~~ 172 bytes
```
 (a,b,c)->{int r[][]=new int[a][a],t=a-b>>1,u=a-c>>1,x=b*b;for(;x-->0;r[x/b+t][x%b+t]=1)if(x<c*c)r[x/c+u][x%c+u]=8;var s="";for(var q:r){for(int Q:q)s+=Q;s+="\n";}return s;}
```
-34 bytes thanks to *@ceilingcat*.
**Explanation:**
[Try it online.](https://tio.run/##jVFBasMwELznFYuhICWyW6dNCFHlY28NhB4dHyTFLkodOZGl1CX47a6U@lpaWGZ3mGHRrA78wuPD/mNQx1NjLBw8T5xVdVI5La1qdPIyDnQia9628MqVvk4AlLalqbgsYRMowJs1Sr@DRF4BTgKKG0pMvaGfeGgtt0rCBjQwGBAngkgcZ9dgM3mRF0yXn2F1zgtfxDIeiyxLifODDEPHxFTQqjGIdnGcPVCTd/diZou8uwuNpVhVqHuWU4mDJGcuSKGxFb1wAy2LotuCQM5rg6@BhBds12fcztiWeoh2OqK9Ka0zGlraDyGDr5MTtU8wBrk0ag9HfxH0kz4vgOPxHF@tLY9J42xy8pKtNdKJREvyROb4dpFfPSuy/NOTzv9hmi9IuiCPePyAfvgG)
```
(a,b,c)->{                  // Method with three integer parameters and String return-type
  int r[][]=new int[a][a],  //  Create a grid with dimensions `a` by `a`,
                            //  filled with 0s by default
      t=a-b>>1,             //  Calculate (a-b)/2
      u=a-c>>1,             //  Calculate (a-c)/2 as well
  x=b*b;for(;x-->0;         //  Loop `x` in the range (b*b, 0]:
    r[x/b+t][x%b+t]=1;      //   Fill the cells for the second square with 1s
    if(x<c*c)               //   And if `x` is smaller than c*c:
      r[x/c+u][x%c+u]=8;    //    Also start filling the center square cells with 8s
  var s="";                 //  Then create a return-String, starting empty
  for(var q:r){             //  Loop over the rows of the matrix:
    for(int Q:q)            //   Inner loop over the columns of the row:
      s+=Q;                 //    Append the current digit to the result-String
    s+="\n";}               //   Append a trailing new-line after every row
  return s;}                //  Return the result-String
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 14 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
#*@Ｈ╶：＊ｌ⁸∔½：╋｝
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JTIzKkAldUZGMjgldTI1NzYldUZGMUEldUZGMEEldUZGNEMldTIwNzgldTIyMTQlQkQldUZGMUEldTI1NEIldUZGNUQ_,i=OCUwQTYlMEEy,v=8)
]