[Question]
  [
The purpose of this challenge is to produce an ASCII version of the cover of [this great album](https://en.wikipedia.org/wiki/The_Wall) by the rock band Pink Floyd.
The brick junctions are made of characters `_` and `|`. Bricks have width 7 and height 2 characters, excluding junctions. So the basic unit, including the junctions, is:
```
_________
|       |
|       |
_________
```
Each row of bricks is **offset by half a brick width** (4 chars) with respect to the previous row:
```
________________________________________
  |       |       |       |       |     
  |       |       |       |       |     
________________________________________
      |       |       |       |       | 
      |       |       |       |       | 
________________________________________
  |       |       |       |       |     
  |       |       |       |       |     
```
The wall is **parameterized** as follows. All parameters are measured in chars including junctions:
1. **Horizontal offset** of first row, `F`. This is the distance between the left margin and the first vertical junction of the upmost row. (Remember also the half-brick relative offset between rows). Its possible values are `0`, `1`, ..., `7`.
2. Total **width**, `W`. This includes junctions. Its value is a positive integer.
3. Total **height**, `H`. This includes junctions. Its value is a positive integer.
The top of the wall always coincides with the top of a row. The bottom may be ragged (if the total height is not a multiple of `3`). For example, here's the output for `6`, `44`, `11`:
```
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     
  |       |       |       |       |       |     
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     
```
and a visual explanation of parameters:
```
          F=6
         ......   
     .   ____________________________________________
     .         |       |       |       |       |    
     .         |       |       |       |       |     
     .   ____________________________________________
     .     |       |       |       |       |       | 
H=11 .     |       |       |       |       |       |      
     .   ____________________________________________
     .         |       |       |       |       |     
     .         |       |       |       |       |     
     .   ____________________________________________
     .     |       |       |       |       |       |      
         ............................................
                             W=44
```
## Additional rules
You may provide a program or a function.
Input format is flexible as usual. Output may be through STDOUT or an argument returned by a function. In this case it may be a string with newlines or an array of strings.
Trailing spaces or newlines are allowed.
Shortest code in bytes wins.
## Test cases
Inputs are in the order given above, that is: horizontal offset of first row, total width, total height.
```
6, 44, 11:
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 
  |       |       |       |       |       | 
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     
2, 20, 10:
____________________
  |       |       | 
  |       |       | 
____________________
      |       |     
      |       |     
____________________
  |       |       | 
  |       |       | 
____________________
1, 1, 1:
_
1, 2, 3:
__
 |
 |
3, 80, 21:
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
```
  
[Answer]
# C, 86 85 83 82 bytes
3 bytes saved thanks to Lynn.  
1 byte saved thanks to charlie.
```
i;f(o,w,h){++w;for(i=0;++i<w*h;)putchar(i%w?i/w%3?i%w+i/w/3*4+~o&7?32:124:95:10);}
```
[Answer]
# C, 92 bytes
```
b(f,w,h,y,x){for(y=0;y<h;y++,puts(""))for(x=0;x<w;x++)putchar(y%3?(x+y/3*4-f)%8?32:124:95);}
```
Invoke as `b(F, W, H)`.
[Answer]
# Pyth, ~~43~~ 27 bytes
I ***need*** to golf it heavily... the score is too shameful.
```
AQVE<*H?%N3X*8d+G*4/N3\|\_H
```
[Try it online already.](http://pyth.herokuapp.com/?code=AQVE%3C%2aH%3F%25N3X%2a8d%2BG%2a4%2FN3%5C%7C%5C_H&input=6%2C44%0A11&debug=0)
### Input format
```
6,44
11
```
### Output format
```
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 
  |       |       |       |       |       | 
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 
```
## Explanation
```
AQVE<*H?%N3X*8d+G*4/N3\|\_H   First two inputs as list in Q,
                              third input as E.
AQ                            Assign G to the first item in Q
                              and H to the second item in Q.
  VE                          For N from 0 to E-1:
                   /N3            N floor-div 3.
                                    if N gives a remainder of 3 or 4 or 5
                                    when divided by 6, this will be odd;
                                    otherwise, this will be even.
                 *4               Multiply by 4.
                                    if the above is odd, this will leave
                                    a remainder of 4 when divided by 8;
                                    otherwise, the remainder would be 0.
               +G                 Add G (as an offset).
           X*8d       \|          In the string "        " (*8d),
                                  replace (X) the character with the
                                  index above with "|" (modular indexing,
                                  hence the manipulation above).
       ?%N3             \_        If N%3 is non-zero, use the above;
                                  otherwise, use "_".
     *H                           The above repeated H times.
    <                     H       Take the first H characters of above.
                                  Implicitly print with newline.
```
[Answer]
# Perl, 63 bytes
```
#!perl -nl
$y+=print+map$y%3?$_++-$`&7?$":'|':_,($y%6&4)x$&for/ \d+/..$'
```
Counting the shebang as 2, input is taken from stdin, whitespace separated.
**Sample Usage**
```
$ echo 2 20 10 | perl bricks.pl
____________________
  |       |       |
  |       |       |
____________________
      |       |
      |       |
____________________
  |       |       |
  |       |       |
____________________
```
[Answer]
## Haskell, 83 bytes
```
q s="_":[s,s]
(f!w)h=take h$cycle$take w.drop(7-f).cycle<$>q"       |"++q"   |    "
```
This defines a ternary infix function `!` which returns a list of strings. Usage example:
```
*Main> putStrLn $ unlines $ (3!14) 7
______________
   |       |  
   |       |  
______________
       |      
       |      
______________
```
How it works:
```
            q"       |"++q"   |    "  -- build a list of 6 strings
                                      --   1:     "_"
                                      --   2:     "       |"
                                      --   3:     "       |"
                                      --   4:     "_"
                                      --   5:     "   |    "
                                      --   6:     "   |    "
         <$>                          -- for each of the strings
     take w.drop(7-f).cycle           -- repeat infinitely, drop the first 7-f chars
                                      --    and take the next w chars
  cycle                               -- infinitely repeat the resulting list
take h                                -- and take the first h elements
```
[Answer]
## JavaScript (ES6), ~~96~~ 95 bytes
```
g=
(f,w,h)=>[...Array(h)].map((_,i)=>(i%3?`       |`:`_`).repeat(w+7).substr(f^7^i%6&4,w)).join`
`
;
```
```
<div onchange=o.textContent=g(f.value,w.value,+h.value)><input id=f type=number min=0 max=7 placeholder=Offset><input id=w type=number min=0 placeholder=Width><input id=h type=number min=0 placeholder=Height></div><pre id=o>
```
Explanation: Creates a string of either the repeating 7 spaces plus `|` pattern or just repeated `_`s, but at least long enough to be able to extract the `w` characters required for each row. The first three rows start at position `f^7` and then the next three rows start at position `f^3`, so I achieve this by ~~toggling bit 2 of `f` on every third row~~ using the opposite bit 2 on the last two rows of each block of 6 for a saving of 1 byte.
[Answer]
# Python 2, ~~93~~ 88 bytes
~~2nd indentation level is tab~~ Saving some bytes thanks to Leaky Nun and some own modifications, also now correct offset:
```
def f(F,W,H):
 for h in range(H):print["_"*W,((("|"+7*" ")*W)[8-F+h%6/3*4:])[:W]][h%3>0]
```
previous code:
```
def f(F,W,H,x="|"+7*" "):
 for h in range(H):
    print ["_"*W,(x[F+4*(h%6>3):]+x*W)[:W]][h%3>0]
```
Same length as unnamed lambda:
```
lambda F,W,H,x="|"+7*" ":"\n".join(["_"*W,(x[F+4*(h%6>3):]+x*W)[:W]][h%3>0]for h in range(H))
```
[Answer]
# MATL, ~~42~~ ~~36~~ 33 bytes
```
:-Q'_ | |'[DClCl]Y"8et4YShwi:3$)!
```
Input format is: `nCols`, `offset`, `nRows`
[**Try it Online**](http://matl.tryitonline.net/#code=Oi1RJ18gfCB8J1tEQ2xDbF1ZIjhldDRZU2h3aTozJCkh&input=NDQKNgoxMQ)
The approach here is that we setup a "template" which we then index into by using the row indices (`[1 2 ... nRows]`) and column indices shifted by the first input (`[1 2 ... nCols] - shift`). Thanks to MATL's modular indexing, it will automatically result in a tiled output. As a side-note, to save some space, technically I work with a transposed version of the template and then just take a transpose (`!`) at the end.
The template is this:
```
________
       |
       |
________
  |     
  |     
```
[Answer]
# QBasic, ~~121~~ 109 bytes
## (Tested on QB64)
Thanks to @DLosc for golfing my `IF` statement with a mathematical equivalent. That was worth 12 bytes.
## General Method:
Loop through each cell one at a time and determine whether it should be a `_`, , or `|` depending on its location. `MOD` statements and boolean logic are used to determine brick boundaries and how much to stagger the bricks.
## Code:
```
INPUT F,W,H
FOR y=0TO H-1:FOR x=0TO W-1
?CHR$((y MOD 3>0)*(((x-(y MOD 6>3)*4)MOD 8=F)*92+63)+95);
NEXT:?:NEXT
```
## Usage Note:
QBasic expects input to be numbers separated by commas.
[Answer]
# Java, ~~149~~, ~~147~~, ~~146~~, 143 bytes
Golfed:
```
String f(int o,int w,int h){String s="";for(int y=0,x;y<h;++y){for(x=0;x<w;++x){s+=y%3>0?(x-o+(y-1)/3%2*4)%8==0?'|':' ':'_';}s+='\n';}return s;}
```
Ungolfed:
```
public class AllInAllItsJustUhAnotherTrickInCodeGolf {
  public static void main(String[] args) {
    int offset = 6;
    int width = 44;
    int height = 11;
    System.out.println(new AllInAllItsJustUhAnotherTrickInCodeGolf()
        .f(offset, width, height));
  }
  // Begin golf
  String f(int o, int w, int h) {
    String s = "";
    for (int y = 0, x; y < h; ++y) {
      for (x = 0; x < w; ++x) {
        s += y % 3 > 0 ? (x - o + (y - 1) / 3 % 2 * 4) % 8 == 0 ? '|' : ' ' : '_';
      }
      s += '\n';
    }
    return s;
  }
  // End golf
}
```
[Answer]
# Ruby, ~~72~~ 66 bytes
```
->f,w,h{h.times{|i|puts i%3<1??_*w:((?|+' '*7)*w)[8-f+i%6/4*4,w]}}
```
Thanks @Value Ink for 6 bytes!
Simple string multiplication and slicing.
Works in Ruby 2.3.0 (Ideone's version 2.1 threw syntax error).
[Answer]
# Julia: ~~150~~ ~~128~~ ~~116~~ ~~108~~ 107 bytes
```
# in codegolf.jl
r=repmat;b=r([' '],6,8);b[[1,4],:]='_';b[[2,3,23,24]]='|';b=r(b,h,w)[1:h,o+=1:o+w];b[:,end]=10;print(b'...)
```
to run with arguments: `julia -e 'o=2;h=18;w=40;include("codegolf.jl")'`
If you feel calling from bash is cheating and you want a function inside the interpreter, then the function version is 117 bytes :)
```
f(o,h,w)=(r=repmat;b=r([' '],6,8);b[[1,4],:]='_';b[[2,3,23,24]]='|';b=r(b,h,w)[1:h,o+=1:o+w];b[:,end]=10;print(b'...))
```
[demo](http://julia.tryitonline.net/#code=ZihvLGgsdyk9KGI9MzIqb25lcyhJbnQzMiw2LDgpO2JbWzEsNF0sOl09OTU7YltbMiwzLDIzLDI0XV09MTI0O2I9cmVwbWF0KGIsaCx3KVsxOmgsbysxOm8rdysxXTtiWzosZW5kXT0xMDtwcmludChyZWludGVycHJldChDaGFyLGInKS4uLikpCmYoMiwgMTgsNDAp&input=)
(Thanks, @glen-o for the extra byte-saving tip!)
[Answer]
## JavaScript, ~~172~~ ~~168~~ ~~165~~ ~~157~~ ~~147~~ ~~142~~ 137 bytes
```
(O,W,H)=>{t='_'.repeat(W),x='|       '.repeat(W),f=t+`
`;for(i=0;++i<H;)f+=(!(i%3)?t:(i%6)>3?x.substr(O,W):x.substr(8-O,W))+`
`;return f}
```
```
N = (O,W,H)=>{t='_'.repeat(W),x='|       '.repeat(W),f=t+`
`;for(i=0;++i<H;)f+=(!(i%3)?t:(i%6)>3?x.substr(O,W):x.substr(8-O,W))+`
`;return f}
let test_data = [[6,44,11],
                 [2,20,10],
                 [1,1,1],
                 [1,2,3],
                 [3,80,21]];
for (test of test_data)
    console.log(N(...test));
```
[Answer]
# Dyalog APL, 29 bytes
`↑⎕⍴⎕⍴¨a,4⌽¨a←'_',2⍴⊂⌽⎕⌽¯8↑'|'`
tests:
[`6 44 11`](http://tryapl.org/?a=F%20W%20H%u21906%2044%2011%20%u22C4%20%u2191H%u2374W%u2374%A8a%2C4%u233D%A8a%u2190%27_%27%2C2%u2374%u2282%u233DF%u233D%AF8%u2191%27%7C%27&run),
[`2 20 10`](http://tryapl.org/?a=F%20W%20H%u21902%2020%2010%20%u22C4%20%u2191H%u2374W%u2374%A8a%2C4%u233D%A8a%u2190%27_%27%2C2%u2374%u2282%u233DF%u233D%AF8%u2191%27%7C%27&run),
[`1 1 1`](http://tryapl.org/?a=F%20W%20H%u21901%201%201%20%u22C4%20%u2191H%u2374W%u2374%A8a%2C4%u233D%A8a%u2190%27_%27%2C2%u2374%u2282%u233DF%u233D%AF8%u2191%27%7C%27&run),
[`1 2 3`](http://tryapl.org/?a=F%20W%20H%u21901%202%203%20%u22C4%20%u2191H%u2374W%u2374%A8a%2C4%u233D%A8a%u2190%27_%27%2C2%u2374%u2282%u233DF%u233D%AF8%u2191%27%7C%27&run),
[`3 80 21`](http://tryapl.org/?a=F%20W%20H%u21903%2080%2021%20%u22C4%20%u2191H%u2374W%u2374%A8a%2C4%u233D%A8a%u2190%27_%27%2C2%u2374%u2282%u233DF%u233D%AF8%u2191%27%7C%27&run)
`⎕` is evaluated input; as the expression executes from right to left, it prompts for `F`, `W`, and `H` in that order
`¯8↑'|'` is `' |'`
`⎕⌽` is rotate, it chops F chars from the front and puts them at the end of the string
the other `⌽` means reverse
`'_',2⍴⊂` creates a 3-tuple of '\_' followed by two separate copies of the string so far
`a,4⌽¨a←` append the 4-rotation of everything so far, we end up with a 6-tuple
`⎕⍴¨` reshape each element to the width
`⎕⍴` reshape to the height
`↑` mix vector of vectors into a matrix
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~25~~ ~~24~~ 23 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
'_'|7úD)³∍ε73N3÷è¹-._²∍
```
-1 byte thanks to *@Grimmy*.
Inputs in the order \$\text{offset}, \text{width}, \text{height}\$.  
Output as a list of string-lines.
[Try it online](https://tio.run/##yy9OTMpM/f9fPV69xvzwLhfNQ5sfdfSe22pu7Gd8ePvhFYd26urFH9oEFPtfe2j3fzMuExMuQ0MA) or [verify all test cases](https://tio.run/##yy9OTMpM/V@m5JlXUFpSbKWgZF@pw6XkX1oC5AJ5OpUJh1bGhIX@V49XrzE/vMtF89C6Rx2957aaG/sZH95@eEWErl58JFDkf@2h3TqaMYe22f@PjjbTMTHRMTSM1Yk20jEy0DE0ALIMdYAQTBvpGANpYx0LAx0jkIiBjqWOSWwsAA).
**Explanation:**
```
'_           '# Push "_"
'|           '# Push "|"
  7ú          # Pad 7 leading spaces: "       |"
    D         # Duplicate it
     )        # Wrap all three values on the stack into a list
³∍            # Extend this list to the (third) input-height amount of lines
              #  i.e. height=7 → ["_","       |","       |","_","       |","       |","_"]
ε             # Map over each line:
   N          #  Push the (0-based) map-index
    3÷        #  Integer-divide it by 3
 73   è       #  Index it into 73 (0-based and with wraparound)
              #   i.e. indices=[0,1,2,3,4,5,6,7,...] → [7,7,7,3,3,3,7,7,...]
       ¹+     #  Subtract the (first) input-offset
              #   i.e. offset=6 → [-3,-3,-3,1,1,1,-3,-3,...]
         ._   #  Rotate the string that many times towards the left
              #   i.e. ["_","       |","       |","_","       |","       |","_"] and 
              #     [-3,-3,-3,1,1,1,-3] → ["_","      | ","      | ","_","  |     ","  |     ","_"]
           ²∍ #  After this inner loop: push the (second) input-width
              #  Extend/shorten the line to a size equal to the (second) input-width
              #   i.e. width=5 and line="   |    " → "   | "
              #   i.e. width=20 and line="   |    " → "   |       |       |"
              #   i.e. width=5 and line="_" → "_____"
              #   i.e. width=20 and line="_" → "____________________"
              # (after which the list of string-lines is output implicitly as result)
```
`73N3÷è` could alternatively be `₃€ÐÍNè` for the same byte-count:
[Try it online](https://tio.run/##ATsAxP9vc2FiaWX//ydfJ3w3w7pEKcKz4oiNzrXigoPigqzDkMONTsOowrktLl/CsuKIjf99wrv/Ngo0NAoxMQ) or [verify all test cases](https://tio.run/##yy9OTMpM/V@m5JlXUFpSbKWgZF@pw6XkX1oC5AJ5OpUJh1bGhIX@V49XrzE/vMtF89C6Rx2957Y@amp@1LTm8ITDvX6HV0To6sVHAoX/1x7araMZc2ib/f/oaDMdExMdQ8NYnWgjHSMDHUMDIMtQBwjBtJGOMZA21rEw0DECiRjoWOqYxMYCAA).
```
 ₃            #  Push builtin 95
  €Ð          #  Triplicate each digit: [9,9,9,5,5,5]
    Í         #  Decrease each by 2: [7,7,7,3,3,3]
     Nè       #  Index the (0-based) map-index into this (0-based and with wraparound)
```
[Answer]
# [Actually](https://github.com/Mego/Seriously), ~~44~~ ~~43~~ 40 bytes
This is an Actually port of the algorithm in [Neil's JS answer](https://codegolf.stackexchange.com/a/90076/47581). Golfing suggestions welcome. [Try it online!](https://tio.run/##S0wuKU3Myan8///R1OmPps4tetSzwNpMQ9VE7dHUOeZxcY@mzlavMVdSUNLS1ioBchw8QCLxWsYaqpGej3oW@mb@/29oyGViwmUGAA "Actually – Try It Online")
```
╗╝r⌠;6(%4&╜7^^╛'|7" "*+*t╛@H╛'_*3(%YI⌡Mi
```
**Ungolfing:**
```
          Takes implicit input in the order h, w, f.
╗╝        Save f to register 0. Save w to register 1.
r⌠...⌡M   Map over range [0..h-1]. Call this variable i.
  ;         Duplicate i
  6(%       i%6...
  4&        ...&4
  ╜7^^      ...^i^7. Call it c.
  ╛         Push w.
  '|7" "*+  The string "       |"
  *t╛@H     (("       |" * w)[c:])[:w]
  ╛'_*      Push "_" * w
  3(%       Push 3, move duplicate i to TOS, mod.
  YI        If not i%3, take "_"*w, else (("       |" * w)[c:])[:w]
            Function ends here.
i         Flatten the resulting list and print the bricks implicitly.
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~101~~ 88 bytes
```
param($n,$w,$h)0..--$h|%{(('|       '*$w|% S*g(8-$n+4*($_%6-gt3))$w),('_'*$w))[!($_%3)]}
```
[Try it online!](https://tio.run/##LY3RCoJAEEXf9ys2GdsZG2NXJSLoK@otRCQsH8xEhX1Iv31zrWG4nDt34HZvW/VDXTWNg8f547qyL18ILYNlqEnv93EM9RR@ENUkf6MisFMoL9ETjzG0uyxCKMJD/BxTIrDEqAr/Q3Tb@CSlfHazEIgHzjI2hlhgwolmoz0aln7/mLBMPaYsj3qxhmipF744uFbDKO/lUJ0kFMF6k1t4LOamc69m1SRfI6XE7L4 "PowerShell – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 30 bytes
```
(n₃[¹\_*,|7\|꘍¹*⁰ǔǔn3ḭ∷[4ǔ]¹Ẏ,
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%28n%E2%82%83%5B%C2%B9%5C_*%2C%7C7%5C%7C%EA%98%8D%C2%B9*%E2%81%B0%C7%94%C7%94n3%E1%B8%AD%E2%88%B7%5B4%C7%94%5D%C2%B9%E1%BA%8E%2C&inputs=10%0A44%0A1&header=&footer=)
A big mess.
```
(                              # (height) times (to make each row)
 n₃[                           # If the iteration is divisible by 3 (flat row) then...
    ¹\_*,                      # (width) underscores
         |                     # Else (part of a brick)...
          7\|꘍                 # Prepend seven spaces to an underscore
              ¹*               # Repeat (width) times
                ⁰ǔǔ            # Cycle by (offset), then cycle once more
                   n3ḭ∷[  ]    # If it's an offset row
                        4ǔ     # Cycle once more
                           ¹Ẏ, # Trim to the correct length and print.
```
[Answer]
# Octave ~~80~~ 76 bytes
```
% in file codegolf.m
c(6,8)=0;c([1,4],:)=63;c([2,3,23,24])=92;char(repmat(c+32,h,w)(1:h,o+1:o+w))
```
to run from terminal: `octave --eval "o=2;h=18;w=44; codegolf"`
(alternatively, if you think the terminal call is cheating :p then an anonymous function implementation takes 86 bytes :)
```
c(6,8)=0;c([1,4],:)=63;c([2,3,23,24])=92;f=@(o,h,w)char(repmat(c+32,h,w)(1:h,o+1:o+w))
```
Call `f(2,18,44)` at the octave interpreter.
[Answer]
# Bash + Sed, ~~411~~ ~~395~~ ~~381~~ 370 bytes:
```
F=`printf '_%.s' $(eval echo {1..$2})`;V="       |";(($[($2-$1)/8]>0))&&L=`printf "$V%.s" $(eval echo {1..$[($2-$1)/8]})`||L=;Z=`printf "%$1.s|%s\n" e "$L"`;I=$[($2-(${#Z}-4))/8];(($I>0))&&W=`printf "$V%.s" $(eval echo {1..$I})`||W=;J=${Z:4}$W;for i in `eval echo {1..$[$3/3+1]}`;{ (($[$i%2]<1))&&O+="$F\n$J\n$J\n"||O+="$F\n$Z\n$Z\n";};echo "`echo -e "$O"|sed -n 1,$3p`"
```
Well, here is my very first answer in Bash, or any shell scripting language for that matter. This is also by far the longest answer here. Takes in a sequence of space-separated command line arguments in the format `Offset Width Height`. This can probably be a lot shorter than it currently is, so any tips and/or tricks for golfing this down more are appreciated.
[Answer]
## Delphi/Object Pascal, 305, 302, 292 bytes
Full console program that reads 3 parameters.
```
uses SySutils,Math;var i,q,o,w,h:byte;begin o:=StrToInt(paramstr(1));w:=StrToInt(paramstr(2));h:=StrToInt(paramstr(3));for q:=0to h-1do begin for i:=1to w do if q mod 3=0then Write('_')else if IfThen(Odd(q div 3),((i+o)mod 8),((i-o)mod 8))=1then Write('|')else Write(' ');Writeln('');end end.
```
### ungolfed
```
uses
  SySutils,
  Math;
var
  i,q,o,w,h:byte;
begin
  o:=StrToInt(paramstr(1));
  w:=StrToInt(paramstr(2));
  h:=StrToInt(paramstr(3));
  for q := 0 to h-1 do
  begin
    for i := 1 to w do
      if q mod 3 = 0  then
        Write('_')
      else
        if IfThen(Odd(q div 3),((i+o)mod 8),((i-o)mod 8)) = 1 then
          Write('|')
        else Write(' ');
    Writeln('');
  end
end.
```
Sadly, Delphi does not have a ternary operator and it is quite a verbose language. 
### test case
```
D:\Test\CodeGolfWall\Win32\Debug>Project1.exe 2 20 10
____________________
  |       |       |
  |       |       |
____________________
      |       |
      |       |
____________________
  |       |       |
  |       |       |
____________________
D:\Test\CodeGolfWall\Win32\Debug>Project1.exe 6 44 11
____________________________________________
      |       |       |       |       |
      |       |       |       |       |
____________________________________________
  |       |       |       |       |       |
  |       |       |       |       |       |
____________________________________________
      |       |       |       |       |
      |       |       |       |       |
____________________________________________
  |       |       |       |       |       |
```
Edit: Could shave of 3 bytes by using byte as type for all variables.
Edit 2: And console applications do not *need* the program declaration, -10 
[Answer]
# JavaScript (ES6), ~~81 78~~ 77 bytes
*Saved 3 bytes thanks to @mypronounismonicareinstate*
Takes input as `(F, W)(H)`.
```
(F,W,x=y=0)=>g=H=>y<H?`
|_ `[x++<W?y%3?(x+~F^y/3<<2)&7?3:1:2:x=+!++y]+g(H):''
```
[Try it online!](https://tio.run/##bczBCsIgAIDhe09hh5qi1dRRITpvY2@wQ1QbaxvFmNEiFKJXN6@xzh//f6te1Vg/rvfnajCXxrfKw4wUxCqnYqTSTuUqdTLX5ex9BuXBYiwL7RZcQ4s/2cltuJQMLXeaCyqYsArPMXZH3MEciSjytRlG0zfr3nSwhVsCkgRBShGa/QojgMVB4olQAgBFENC/woLwiXAC9uHGQuO/ "JavaScript (Node.js) – Try It Online")
]