[Question]
  [
COBOL is a very old language, at the time of writing it is 58 years old.
It is so old, in fact, that it has a very interesting quirk: the first six characters of each line are comments.
Why is this, you ask? Well, those 6 characters were intended to be used as line numbers, back in the day where programs weren't completely digital and typed out on a computer.
In addition, the seventh character could only be part of a very small set (it is usually `*` to comment out the line or a space to separate the line number from the code)
But what if you're on a more digital system, and you just want the raw program?
## The comment system
There are two types of comments in COBOL: line comments and the aforementioned "line number" comments.
Uncommenting line numbers is simple: just take the first seven (six plus a single space) characters off each line.
```
000000 apple
000001 banana
celery donuts
```
would become:
```
apple
banana
donuts
```
Line comments make it a bit more difficult.
A line comment is started with an asterisk `*` placed in the seventh character position on the line, like so:
```
000323* this is a comment
```
This is not a line comment:
```
*00000 this isn't a comment
```
To uncomment a line comment, just remove the whole line.
An example commented "program":
```
000000 blah blah
000001* apples
000002 oranges?
000003* yeah, oranges.
000*04 love me some oranges
```
The uncommented version:
```
blah blah
oranges?
love me some oranges
```
In other words, to uncomment a string, remove the first six characters of each line, then return all but the first character of every line that does not begin with a star.
## The challenge
Create a program or function that takes a commented program and returns its uncommented variant.
## Clarifications
* Asterisks (`*`) will never be found anywhere outside the first seven characters on a line (we're not asking you to verify syntax)
* Each line will always have at least 7 characters.
* You may assume the seventh character is always an asterisk or a space.
* Input or output may be a matrix or list.
* Only printable ASCII characters (plus newline) must be handled.
* You may output with a trailing newline. You may also assume that the input will have a trailing newline, if you so choose.
## Scoring
Since this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the answer with the least bytes wins!
DISCLAIMER: I do not actually know COBOL and do not claim to. If any of the claims about COBOL I have made in this question are incorrect, I take no responsibility.
  
[Answer]
# COBOL (GnuCOBOL), 191 + 17 = 208 bytes
I "learned" COBOL for this answer, so it's probably not fully golfed.
This is a full program, taking input on what I presume to be standard input and writing to what I presume to be standard output. Perhaps one day I'll return to this and (1) determine whether COBOL has functions and, if so, (2) see whether a function solution would be shorter.
Byte count includes program and compiler flags (`-free` and `-frelax-syntax`).
```
program-id.c.select i assign keyboard line sequential.fd i. 1 l pic X(80). 88 e value 0.open input i perform until e read i end set e to true end-read if not e and l(7:1)<>'*'display l(8:73).
```
[Try It Online](https://tio.run/##NY/BboMwEETv/Yq5JaBiQVMpKKra38h1gYVYXWzXNlH4@VAD7R5Gmje7I21rGyvFYKZlcd4OnsZCd6pVgYXbCA0KQQ8G3zw3lnwH0YYR@GdiEzWJ6jtohQoCp1tcj3WZKdQ1GHeSiVEq69hAGzetdY59b/2IKV1LWvJMqQBsulQaE4gW0ae7RIo97GHsmlDakeP5UmUfn4f80OnghOaE6sv5lKllKbdBI3Tb5GXzVQ5yTjjs9g3Wkxk4fO3@lGNmur3@Y7XivHyH2DtjTL/aJH/hs@2FhrAUvWfeVOhRhNlEevwC)
## Ungolfed program
```
program-id. c.
select i assign to keyboard organization line sequential.
fd i.
    1 l pic X(80).
    88 e value 0.
open input i
perform until e
    read i
        end set e to true
    end-read
    if not e and l(7:1) <> '*'
        display l(8:73).
```
## Limitations
The output is, technically speaking, not correct. From my cursory research, it seems the only practical way to store a string in COBOL is in a fixed-size buffer. I have chosen a buffer size of 80 characters, since this is the line length limit for fixed-format programs. This presents two limitations:
* Lines longer than 80 characters are truncated.
* Lines shorter than 80 characters are right-padded with spaces.
I'm guessing this is acceptable since, well, it's COBOL. If not, I'd be willing to look into alternatives.
## Acknowledgments
* -166 bytes thanks to Edward H
* -2 bytes thanks to *hornj*
[Answer]
# [Python 2](https://docs.python.org/2/), ~~39~~ ~~38~~ 37 bytes
*-1 byte thanks to LyricLy. -1 byte thanks to Mego.*
```
lambda s:[i[7:]for i in s if'*'>i[6]]
```
[Try it online!](https://tio.run/##PYlBCsIwFAWv8nbRUKRWUShUDxKz@MXEfkiTkBShp49Sa2cxi5k4T0PwTbHdozga@ycht4rVtdU2JDDYI4OtkOLG6qJ1iYn9BLtTol5A72hYJCr82lGCYnQmb6VBSORfJt@3dJKYDQ3V/xzWI@szXHgbjAY5fLV@offlAw "Python 2 – Try It Online")
I/O as lists of strings.
[Answer]
# [Perl 5](https://www.perl.org/), ~~19~~ + 1 (-p) = ~~20~~ 16 bytes
*-4 bytes with Pavel's suggestions*
```
s/.{6}( |.*)//s
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX6/arFZDoUZPS1Nfv/j/fwMwUEjKScwAE1xgvqGWQmJBQU5qMYRrpJBflJiXnlpsD@EbaylUpiZm6MCE9UDCWgYmCjn5ZakKuakKxflAAir5L7@gJDM/r/i/rq@pnoGhwX/dAgA "Perl 5 – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~13~~ ~~11~~ 10 bytes
```
Î6x<<
çª/d
```
[Try it online!](https://tio.run/##K/v//3CfWYWNDdfh5YdW6af8/28ABgpJOYkZYIILzDfUUkgsKMhJLYZwjRTyixLz0lOL7SF8Yy2FytTEDB2YsB5IWMvARCEnvyxVITdVoTgfSEAlAQ "V – Try It Online")
### Explanation
```
Î       ' On every line
  x     ' delete the first...
 6      ' 6 characters
   <<   ' and unindent the line (removes the leading space)
ç /     ' on every line
 ª      ' matching \*
   d    ' delete the line
```
Hexdump:
```
00000000: ce36 783c 3c0a e7aa 2f64                 .6x<<.../d
```
[Answer]
# [Paradoc](https://github.com/betaveros/paradoc) (v0.2.8+), 8 bytes (CP-1252)
```
µ6>(7#;x
```
Takes a list of lines, and results in a list of uncommented lines.
Explanation:
```
μ        .. Map the following block over each line (the block is terminated
         .. by }, but that doesn't exist, so it's until EOF)
 6>      .. Slice everything after the first six characters
   (     .. Uncons, so now the stack has the 6th character on top
         .. and the rest of the line second
    7#   .. Count the multiplicity of factors of 7 in the character
         .. (treated as an integer, so '*' is 42 and ' ' is 32)
      ;  .. Pop the top element of the stack (the rest of the line)...
       x .. ...that many times (so, don't pop if the 6th character was a
         .. space, and do pop if it was an asterisk)
```
Hi, I wrote a golfing programming language. :)
I'm still developing this and added/tweaked a bunch of built-ins after trying to write this so that there are more reasonable ways to differentiate between a space and an asterisk than "`7#`", but I feel like that would make this noncompeting. It's fortunate that it still worked out (this only uses features from v0.2.8, which I committed three days ago).
[Answer]
# Octave, 23 bytes
```
@(s)s(s(:,7)~=42,8:end)
```
[Try it online!](https://tio.run/##y08uSSxL/f/fQaNYs1ijWMNKx1yzztbESMfCKjUvRfN/mq1CYl6xNVexbTSXkgEYKCTlJGaACSWokKGWQmJBQU5qMUzASCG/KDEvPbXYHiZirKVQmZqYoQOT0INIaBmYKOTkl6Uq5KYqFOcDCai0Uqw1F1ca0E3/AQ "Octave – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~11~~ 9 bytes
```
ṫ€7Ḣ⁼¥Ðf⁶
```
[Try it online!](https://tio.run/##y0rNyan8///hztXmKo@a1hza@nDHIttHjdsObT08Ie3/4fbI//@jlQzAQCEpJzEDTCjpQIQMtRQSCwpyUothAkYK@UWJeempxfYwEWMthcrUxAwdmIQeRELLwEQhJ78sVSE3VaE4H0hApZViAQ "Jelly – Try It Online")
Inputs and outputs as a list of lines.
*-2 bytes thanks to @EriktheOutgolfer and @JonathanAllan*
**How it works**
```
ṫ€7Ḣ=¥Ðf⁶
 €           On each line:
ṫ 7            Replace the line with line[7:]
      Ðf     Keep all lines that meet condition:
     ¥         Dyad:
   Ḣ             First Element (modifies line)
    =            Equals
        ⁶    Space
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 32 bytes
```
$input-replace'^.{6}( |.*)'-ne''
```
[Try it online!](https://tio.run/##NYnLCsIwEEX3fsUshGiwoT5w658Io1yMMCZDYiuifnu0ab2LA@dcjQ@k7CFSyvwatLs3CSp8hjm61/6zoLezS9MEGFNKW0cnYV8xq762xKqCPOqGYuJwQT6MvrX0BPvVP7sh23ZHEnvQDZTjD9P5BQ "PowerShell – Try It Online")
Pipeline input comes in as an array of strings, `-replace` works on every string, and `-ne ''` (not equal to empty string) applied to an array, acts to filter out the blank lines.
[Answer]
# Vim, 14 bytes
`Ctrl-V``G5ld:%g/\*/d``Enter`
Loading the input file as the buffer to edit, then enter the above commands. Output is the new buffer.
[Answer]
# [Pyth](https://pyth.readthedocs.io), 9 bytes
Note that this only works if at least 1 line is *not* a comment and at least 1 line *is* a comment. All the other solutions work in all cases.
*-2 bytes thanks to [@pizzakingme](https://codegolf.stackexchange.com/users/72796/pizzakingme)!*
```
m>d7.m@b6
```
**[Try it here!](https://pyth.herokuapp.com/?code=m%3Ed7.m%40b6&input=%5B%22000000+blah+blah%22%2C+%22000001%2a+apples%22%2C+%22000002+oranges%3F%22%2C+%22000003%2a+yeah%2C+oranges.%22%2C+%22000%2a04+love+me+some+oranges%22%5D&debug=0)**
### Explanation
```
m>d7.m@b6     - Full program with implicit input. Takes input as a list of Strings.
m>d7          - All but the first 7 letters of 
    .m   (Q)  - The input, filtered for its minimal value using the < operator on
      @b6     - the 7th character -- note that "*" is greater than " "
              - Implicitly Output the result.
```
---
# [Pyth](https://pyth.readthedocs.io), 11 bytes
```
tMfqhTdm>d6
```
**[Try it here!](https://pyth.herokuapp.com/?code=tMfqhTdm%3Ed6&input=%5B%22000000+blah+blah%22%2C+%22000001%2a+apples%22%2C+%22000002+oranges%3F%22%2C+%22000003%2a+yeah%2C+oranges.%22%2C+%22000%2a04+love+me+some+oranges%22%5D&debug=0)**
### Explanation
```
tMfqhTdm>d6 - Full Program with implicit input. Takes input as a list of Strings.
       m>d6 - Remove the first 6 characters of each line.
    hT      - Get the first character of each.
  fq  d     - Keep those that have the first character an asterisk.
tM          - Remove the first character of each.
            - Output Implicitly.
```
---
# [Pyth](https://pyth.readthedocs.io), 11 bytes
```
m>d7fqd@T6Q
```
**[Try it here!](https://pyth.herokuapp.com/?code=m%3Ed7fqd%40T6Q&input=%5B%22000000+blah+blah%22%2C+%22000001%2a+apples%22%2C+%22000002+oranges%3F%22%2C+%22000003%2a+yeah%2C+oranges.%22%2C+%22000%2a04+love+me+some+oranges%22%5D&debug=0)**
### Explanation
```
m>d7fq@T6dQ  - Full program. Takes input as a list of Strings.
      @T6    - The sixth character of each.
    fq   dQ  - Keep the lines that have a space as ^.
m>d7         - Crop the first 7 characters.
             - Output implicitly.
```
---
# [Pyth](https://pyth.readthedocs.io), 12 bytes
```
tMfnhT\*m>d6
```
**[Try it here!](https://pyth.herokuapp.com/?code=tMfnhT%5C%2am%3Ed6&input=%5B%22000000+blah+blah%22%2C+%22000001%2a+apples%22%2C+%22000002+oranges%3F%22%2C+%22000003%2a+yeah%2C+oranges.%22%2C+%22000%2a04+love+me+some+oranges%22%5D&debug=0)**
### Explanation
```
tMfnhT\*m>d6 - Full Program with implicit input. Takes input as a list of Strings.
        m>d6 - Remove the first 6 characters of each line.
    hT       - Get the first character of each.
  fn  \*     - Filter those that aren't equal to an asterisk.
tM           - Remove the first character of each.
             - Output Implicitly.
```
---
# [Pyth](https://pyth.readthedocs.io), 12 bytes
```
m>d7fn@T6\*Q
```
**[Try it here!](https://pyth.herokuapp.com/?code=m%3Ed7fn%40T6%5C%2aQ&input=%5B%22000000+blah+blah%22%2C+%22000001%2a+apples%22%2C+%22000002+oranges%3F%22%2C+%22000003%2a+yeah%2C+oranges.%22%2C+%22000%2a04+love+me+some+oranges%22%5D&debug=0)**
### Explanation
```
m>d7fn@T6\*Q  - Full program. Takes input as a list of Strings.
      @T6     - Get the sixth character of each string
    fn   \*Q  - And filter those that aren't equal to an asterisk.
m>d7          - Crop the first 7 characters.
              - Output implicitly.
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 53 48 46 bytes
```
x;main(y){for(y=&x;gets(y-6);x&2||puts(y+1));}
```
[Try it online!](https://tio.run/##NYnBDoIwEAXvfsWeSFvFABoujfFb1mYtJoU2VEgb8durFH2HSWaeKrVSKQXZ42Ngkb/udmTxUgSp6elZLFsuQ9Esi5tW3decy3dKVR7cDHYZu@y1AHTOkN@0ATvioMlfNz8JiITd4Z@PaxbVGYydCXoCb7/4nR8 "C (gcc) – Try It Online")
*-5 bytes:* It was very tricky to get this "*whole program*" down to the same size as [gurka's function](https://codegolf.stackexchange.com/a/140346/71420). It's now writing out of bounds (in both directions) of an array of wrong type and relies on *little endian* and *4 byte integers* to find the asterisk ... but hey, it works ;)
*-2 bytes:* Well, if we already write to some "random" `.bss` location, why bother declaring an *array* at all! So here comes the string handling program that uses *neither* the `char` type *nor* an array.
[Answer]
# C, ~~63~~ ~~59~~ ~~55~~ ~~48~~ ~~47~~ 46 bytes
Thanks to "*an anonymous user*" for getting rid off yet another byte.
Thanks to [Felix Palmen](https://codegolf.stackexchange.com/users/71420/felix-palmen) for reminding me of "*You may assume the seventh character is always an asterisk or a space.*", which shaved off one more byte.
```
f(char**a){for(;*a;++a)(*a)[6]&2||puts(*a+7);}
```
Use like:
```
char** program = { "000000 apple", "000001 banana", "celery donuts", 0 };
f(program);
```
[Try it online!](https://tio.run/##ZZDbCoMwDIav9SmCF6OtbrgD24WMPYh4Ebt6AG1F3UDUZ3ddnSIshaT5kv4N4fuU82lKCM@wZgxpn6iaBAwD10VKNAiv0e40DNWrbXTq3mgwTrlsocRcEmr3tmWeAoYR3EGnluMbA6yqQjjeSo4Qo9RnRlwUou7gqaRWNsi3rTFY5OI/ubjAzLitJJt/aTbsBKpGmYrmsYFnBp3AzFtqh7XG/AsU6i2gFNAo7X4dm5FsKyFI9WhmCY7zvSYk1mGcPg "C (gcc) – Try It Online")
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~72~~ ~~70~~ ~~66~~ 50 bytes
```
R	INPUT POS(6) (' '  REM . OUTPUT | '*') :S(R)
END
```
[Try it online!](https://tio.run/##NYndCoIwAEav8ym@u80RYiVddBOVi6z8YeoDTBh5sZw0CILefaXWd3HgnM92pjE6ck7MkqyoKxR5Sdc@KAEBBE8RIK@r4XmDMOJjU1LhezyLnQvHodGyHeGNvmCQfa@VnXQJ85DdTdnt5CuGl5Lt/J@DIbMwgjZPhbuCNV/8Tm@3P8T8iFNyvlzTDw "SNOBOL4 (CSNOBOL4) – Try It Online")
Pattern matching in SNOBOL is quite different from regex but the idea here is still the same: If a line matches "six characters and then an asterisk", remove it, otherwise, remove the first seven characters of the line and print the result.
This now actually takes better advantage of SNOBOL's conditional assignment operator.
The pattern is `POS(6) (' ' REM . OUTPUT | '*')` which is interpreted as:
Starting at position 6, match a space or an asterisk, and if you match a space, assign the rest of the line to `OUTPUT`.
[Answer]
# [Actually](https://github.com/Mego/Seriously), 13 bytes
```
⌠6@tp' =*⌡M;░
```
Input and output is done as a list of strings.
Explanation:
```
⌠6@tp' =*⌡M;░
⌠6@tp' =*⌡M    for each line:
 6@t             discard the first 6 characters
    p            pop the first character of the remainder
     ' =         is it a space?
        *        multiply the string by the boolean - returns the string if true, and an empty string if false
           ;░  filter out empty strings
```
[Try it online!](https://tio.run/##S0wuKU3Myan8//9RzwIzh5ICdQVbrUc9C32tH02b@P9/tJIBGCgk5SRmgAklHYiQoZZCYkFBTmoxTMBIIb8oMS89tdgeJmKspVCZmpihA5PQg0hoGZgo5OSXpSrkpioU5wMJqLRSLAA "Actually – Try It Online")
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), 9 bytes
```
6>¦'*«⁈ḥ¦
```
A function accepting a list of strings and returning a list of strings.
[Try it online!](https://tio.run/##S0/MTPz/38zu0DJ1rUOrHzV2PNyx9NCy/6mP2ib@j37UMMcADBSSchIzwMSjhrkKMGFDLYXEgoKc1GJkQSOF/KLEvPTUYntkUWMthcrUxAwdmKQeQlLLwEQhJ78sVSE3VaE4H0hAlQBVxAIA "Gaia – Try It Online")
### Explanation
```
6>¦        Remove the first 6 characters of each string
   '*«⁈    Filter out ones that start with *
       ḥ¦  Remove the initial space from each
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~39~~ ~~38~~ ~~36~~ ~~29~~ ~~23~~ ~~22~~ 20 + 1 = 21 bytes
```
$_[/.{6}( |.*
)/]=''
```
[Try it online!](https://tio.run/##KypNqvz/XyU@Wl@v2qxWQ6FGT4tLUz/WVl39/38DMFBIyknMABNcYL6hlkJiQUFOajGEa6SQX5SYl55abA/hG2spVKYmZujAhPVAwloGJgo5@WWpCrmpCsX5QAIq@S@/oCQzP6/4v24BAA "Ruby – Try It Online")
Uses `-p` flag.
Explanation:
The `-p` flag adds an implicit block around the code, so the code that actually gets run looks like this:
```
while gets
    $_[/.{6}( |.*
)/]=''
    puts $_
end
```
`gets` reads a line of text and stores its result in `$_`. 
`$_[/.../]=''` removes the first occurence of the regex `...` in `$_`.
`/.{6}( |.*\n)/` matches 6 of any character at the start of a line, followed by either a space or the rest of the line. Because the space appears first, it will try to remove only the first 6 characters and a space before attempting to remove the entire line.
`$_` is then printed out, and this process is repeated for each line.
[Answer]
# GNU Sed, 19 + 2 = 21 characters
Requires `-E` argument to `sed` to enable extended regular expressions.
```
/^.{6}\*/d;s/^.{7}/
```
[Answer]
# Java 8, 40 bytes
Regular expressions: just about, but not quite, the wrong tool for the job. Lambda from `String` to `String` (assign to `Function<String, String>`). Input must have a trailing newline.
```
s->s.replaceAll("(?m)^.{6}( |.*\\n)","")
```
[Try It Online](https://tio.run/##ZVFNb8IwDD3TX2H1lFQQsQ9xYYCmTbvtxHHdJFMMhKVO1aTdGOO3d6Etmqbl4K/nZ78ke6xxZAvi/fq9KaqV0RlkBp2DZ9QMx2hQlLpGT@A8@gBuNKOBfaCpymujNhVnXltWT31wt/Sl5u0QOj@HULd5Tuwf7MoamDVuNHeqpMJgRvfGiFgscvmmjpOTgG@VpCnLeBjHshlMo7C/E9Wvr61eQx6kiW78yyugDCoHv4qWGTJTCa73M2D6gH@4WB6cp1xpltPA77tV5eiRjM61Dy1xmn7FLdw328qr8CDsxd9bKSwKcxCXIUyfXkh5Zp6iUzNuD6wM7loTtflVAmcWuS69Blsib8ktuvwmgQPhbngpq3M5Gd@CsTVBHj7EBtOD0Q8)
## Acknowledgments
* -3 bytes thanks to [Sven Hohenstein's regex](https://codegolf.stackexchange.com/a/140316)
[Answer]
# [Haskell](https://www.haskell.org/), ~~27~~ 25 bytes
Laikoni's version is shorter than mine:
```
f n=[x|' ':x<-drop 6<$>n]
```
[Try it online!](https://tio.run/##NYlNCoMwFAav8hEEIVixP3RRtB5EXLzSZyONSUiKWOjd06LNLGYxoyg8WesYB5imWz458stS7@7eOpzr7Gr6ONFo0MD50byQYehEtYKbJrVKFFvaS5BzmkMKB1hP5sGhTeUo8WZSRRrlNmR1grYzY2IE@9N/iz5@AQ "Haskell – Try It Online")
My version:
```
f n=[drop 7x|x<-n,x!!6<'*']
```
[Try it online!](https://tio.run/##NYlNCsIwFAav8jUIhRCl/mA3LR6kdPHEV1tMk5CIRPDuUVozi1nMjBQerHVKA0zb3bx1qOMnNlujYlGcm1KWfZppMmjh/GSe2GDoRLWAq6ZxkVBr2kuQc5pDDgdYT@bO4ZLLUeLNNKo8duuQ1QnavhgzI9if/lv06Qs "Haskell – Try It Online")
[Answer]
## R, 47 45 bytes
```
function(x)gsub("(?m)^.{6}( |.*\\n)","",x,,T)
```
[Answer]
# APL, 23 bytes
* 23 bytes assuming [SBCS](https://github.com/abrudz/SBCS). In UTF-8 it'll be **42 bytes**
This is my first ever attempt at a code golf challenge, feel free to improve, i'm sure i could have saved one or two characters if i wasn't so adamant on making this code *'tacit'*
This assumes the input is a list of lines and return a list of uncommented lines, this makes everything a bit easier since APL was explicitly made to work on list!
```
(('*'≠7∘⌷)⊢⍤/(8≤⍳8)∘⊂)¨
```
Go ahead and [try it!](https://razetime.github.io/APLgolf/?h=AwA&c=09BQ11J/1LnA/FHHjEc92zUfdS161LtEX8PiUeeSR72bLTRB4l1NmodWAAA&f=S1NQNwADhaScxAwwoQ4VMtRSSCwoyEkthgkYKeQXJealpxbbw0SMtRQqUxMzdGASehAJLQMThZz8slSF3FSF4nwgAZVWBwA&i=AwA&r=tryapl&l=apl-dyalog&m=dfn&n=f#) (Thanks @Sʨɠɠan)
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 9 bytes
```
36 4C 3E 23 64 DE 29 6D 74
```
[Try it here!](http://pyke.catbus.co.uk/?code=36+4C+3E+23+64+DE+29+6D+74&input=%22000323%2a+this+is+a+comment%22%2C%22000000+apple%22%2C%22000323%2a+this+is+a+comment%22%2C%22000001+banana%22%2C%22celery+donuts%22&warnings=1&hex=1)
Readable:
```
6L>#d.^)mt
```
[Try it here!](http://pyke.catbus.co.uk/?code=6L%3E%23d.%5E%29mt&input=%22000323%2a+this+is+a+comment%22%2C%22000000+apple%22%2C%22000323%2a+this+is+a+comment%22%2C%22000001+banana%22%2C%22celery+donuts%22&warnings=1&hex=0)
```
6L>        -   [i[6:] for i in input]
   #d.^)   -  filter(i.startswith(" ") for  i in ^)
        mt - [i[-1:] for i in ^]
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~23~~ 15 bytes
*5 bytes saved thanks to [nmjcman101](https://codegolf.stackexchange.com/users/62346/nmjcman101)  
1 byte saved thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil)*
```
m`^.{6}( |.*¶)
```
[Try it online!](https://tio.run/##K0otycxL/P8/NyFOr9qsVkOhRk/r0DZNrv//DcBAISknMQNMcIH5hloKiQUFOanFEK6RQn5RYl56arE9hG@spVCZmpihAxPWAwlrGZgo5OSXpSrkpioU5wMJqCQXAA)
[Answer]
# JavaScript, ~~44~~ 34 bytes
*[Crossed-out 44 is still regular 44.](https://codegolf.stackexchange.com/questions/139375/generate-every-ascii-string/139382#139382)*
*6 bytes saved thanks to [tsh](https://codegolf.stackexchange.com/users/44718/tsh)*
```
a=>a.replace(/^.{6}( |.*\n)/gm,'')
```
[Try it online!](https://tio.run/##NYnLDoIwEEX3fsXsaBss@Igbg/6IMYx1KJrSaaghMeq3VwW9i5Occ684YDT9Jdzmns@UmiphtUPdU3BoSBRH/di8BDy1OnhZ2C7PMpkM@8iOtGMrGlGX4@DksB0xG32hAENwFCddAvfoLcX95CsFd8I2/2f9zapcg@OBoCOI/MHvrKXcpjc)
[Answer]
# JavaScript (ES6), 48 bytes
```
s=>s.map(c=>c[6]<"*"?console.log(c.substr(7)):1)
```
[Try it online!](https://tio.run/##NY1BDoIwFET3nuKnq7bRBtRoohYOIi5KbQRT2oZfCXL5qgRn8ZJ5s5inGhTqvg1x4/zdJGsijCCBZHOgtqqZUblZ5BxUCNbg0rfge@UeBstF7Di8jWrWfy9mz7M9WD8Y6Ayg/2JZyXn1e5xkQlmg6FSgWhb6erhdCCel9g69NcL6B9UCXzXGnh4ZO@UsTXQUGGwbKakcYSx9AA "JavaScript (Node.js) – Try It Online")
[Answer]
# ><>, ~~57~~ 53 Bytes
```
>i~i~i~i~i~i~i67*=\
<o$/?:$/?=a:;?(0:i<
\~$/~\ $
/  <o\?/
```
[try it online](https://tio.run/##S8sszvj/3y6zDgmamWvZxnDZ5Kvo21sBsW2ilbW9hoFVpg1XTJ2Kfl2MggqXvoKCTX6Mvf7//wZgoJCUk5gBJrjAfEMthcSCgpzUYgjXSCG/KDEvPbXYHsI31lKoTE3M0IEJ64GEtQxMFHLyy1IVclMVivOBBFQSAA)
## Explanation
```
>i~i~i~i~i~i~i67*=    Read in the first seven bytes of the line
 i~i~i~i~i~i~         Read, and discard 6 characters
             i        Read the seventh
              67*=    Check if the seventh character was an 
                      asterisk (and leave that value on the stack );
<o$/?:$/?=a:;?(0:i<    Read characters until a newline or eof
                 i     Read the next character of the line
            ;?(0:      If it's a -1, terminate the program
       /?=a:           If it's a newline, break out of the loop
   /?:$                If the seventh character was not an asterisk
<o$                    Output this character
\~$/                   otherwise discard it
   /~\ $    Having reached the end of the line, output
/  <o\?/    the newline only if it was not a comment
```
# Edit: 53 bytes
```
>   i~i~i~i~i~i~i67*=\
/?=a<o/?$@:$@:$;?(0:i<
~   \~/
```
Basically the same stuff as before, but restructured slightly
~~As a side note: I'm disappointed no-one's done this in cobol yet.~~
[Answer]
# C#, ~~160 145 90~~ 89 bytes
```
t=>{var o="";foreach(var s in i.Split('\n'))if(s[6]!=42)o+=s.Substring(7)+"\n";return o;}
```
Thanks to Pavel & auhmaan for reducing the size.
[Answer]
## Python 3, 62 bytes (no regex)
```
def f(s):
 for w in s.split('\n'):
  if w[6]!='*':print(t[7:])
```
It works!
```
>>> s="""000000 blah blah
000001* apples
000002 oranges?
000003* yeah, oranges.
000*04 love me some oranges"""
>>> f(s)
blah blah
oranges?
love me some oranges
```
[Answer]
# [sed](https://www.gnu.org/software/sed/), 11 bytes + 3 bytes option `-nr` = 14 bytes.
```
s/^.{6} //p
```
[Try it online!](https://tio.run/##K05N0U3PK/3/v1g/Tq/arFZBX7/g/38DMFBIyknMABNcYL6hlkJiQUFOajGEa6SQX5SYl55abA/hG2spVKYmZujAhPVAwloGJgo5@WWpCrmpCsX5QAIq@S@/oCQzP6/4v25eEQA "sed – Try It Online")
# [sed](https://www.gnu.org/software/sed/), 16 bytes
```
#n
s/^.\{6\} //p
```
[Try it online!](https://tio.run/##K05N0U3PK/3/XzmPq1g/Ti@m2iymVkFfv@D/fwMwUEjKScwAE1xgvqGWQmJBQU5qMYRrpJBflJiXnlpsD@EbaylUpiZm6MCE9UDCWgYmCjn5ZakKuakKxflAAioJAA "sed – Try It Online")
`#n` on top of line is for `-n`, which is ~~GNU-extension~~ [POSIX-compatible](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html).
[Answer]
# [CLC-INTERCAL](https://esolangs.org/wiki/CLC-INTERCAL), 116 bytes.
```
DO;1<-#6DO,1<-#999DOCOMEFROM.1DOWRITEIN;1+,1(91)DO.1<-,1SUB#2(1)DO.2<-.1~#1DDOCOMEFROM.2DO,1SUB#3<-#0(95)DOREADOUT,1
```
[Try it online, although you need to copy and paste!](http://golf.shinh.org/check.rb)
## Assumption
* Each line should have <=80 characters except trailing newline character(s), although this program can handle up to 339 characters per line (or more, depending on what kind of characters are used).
* Does not matter whether input has trailing newline or not.
## Explaination
```
DONOTE stores first six characters of line
DO;1<-#6
DONOTE stores rest of characters of line except trailing newline
DO,1<-#999
DONOTE label one
DOCOMEFROM.1
DOWRITEIN;1+,1
DONOTE goto label one if tail one is asterisk
DONOTE first two items of tail one shall be
DONOTE 91 and 95 if space, or
DONOTE 91 and 95 if asterisk
(91)DO.1<-,1SUB#2
DONOTE goto label two if line is not empty
DONOTE obtw every item of tail will be zero
DONOTE if empty line
(1)DO.2<-.1~#1
DONOTE die here
D
DONOTE label two
DOCOMEFROM.2
DONOTE erase the space
DONOTE obtw zeros on tail are ignored
DONOTE when reading out
DONOTE see source code for more info
DO,1SUB#3<-#0
DONOTE goto label 1 after reading out
(95)DOREADOUT,1
```
]