[Question]
  [
Given the coordinates of the centres and the radii of 2 circles, output a truthy value of whether they do or do not overlap.
## Input
* Input may be taken via STDIN or equivalent, function arguments, but not as a variable. You can take them as a single variable (list, string etc) or as multiple inputs / arguments, in whatever order you want.
* The input will be six floats. These floats will be up to 3 decimal places. The coordinates can be positive or negative. The radii will be positive.
## Output
* Output can be via STDOUT or function return.
* The program must have exactly 2 distinct outputs - one for a True value (the circles do overlap) and one for a False output (they don't overlap).
### Test cases
(Input is given as list of tuples `[(x1, y1, r1), (x2, y2, r2)]` for the test cases; you can take input in any format)
### True
```
[(5.86, 3.92, 1.670), (11.8, 2.98, 4.571)]
[(8.26, -2.72, 2.488), (4.59, -2.97, 1.345)]
[(9.32, -7.77, 2.8), (6.21, -8.51, 0.4)]
```
### False
```
[(4.59, -2.97, 1.345), (11.8, 2.98, 4.571)]
[(9.32, -7.77, 2.8), (4.59, -2.97, 1.345)]
[(5.86, 3.92, 1.670), (6.21, -8.51, 0.4)]
```
---
This is Code Golf, shortest answer in bytes wins.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
IA<S}
```
Takes two complex numbers (centers) as first argument, and two real numbers (radii) as second argument.
[Try it online!](https://tio.run/##y0rNyan8/9/T0Sa49v///6Z6FmYK2grGepZGWToKhoZ6FkCekZ6lRdZ/Qz0zcwMdBRM9U3NDAA "Jelly – Try It Online")
### How it works
```
IA<S}  Main link.
       Left argument:  [x1 + iy1, x2 + iy2]
       Right argument: [r1, r2]
I      Increments; yield (x2 - x1) + i(y2 - y1).
 A     Absolute value; yield √((x2 - x1)² + (y2 - y1)²).
   S}  Take the sum of the right argument, yielding r1 + r2.
  <    Compare the results.
```
[Answer]
## JavaScript (ES6), 38 bytes
Takes input as 6 distinct variables ***x1***, ***y1***, ***r1***, ***x2***, ***y2***, ***r2***.
```
(x,y,r,X,Y,R)=>Math.hypot(x-X,y-Y)<r+R
```
### Test cases
```
let f =
(x,y,r,X,Y,R)=>Math.hypot(x-X,y-Y)<r+R
// True
console.log(f(5.86, 3.92, 1.670, 11.8, 2.98, 4.571))
console.log(f(8.26, -2.72, 2.488, 4.59, -2.97, 1.345))
console.log(f(9.32, -7.77, 2.8, 6.21, -8.51, 0.4))
// False
console.log(f(4.59, -2.97, 1.345, 11.8, 2.98, 4.571))
console.log(f(9.32, -7.77, 2.8, 4.59, -2.97, 1.345))
console.log(f(5.86, 3.92, 1.670, 6.21, -8.51, 0.4))
```
[Answer]
# Pyth, 5 bytes
```
gsE.a
```
Input format:
```
[x1, y1], [x2, y2]
r1, r2
```
[Try it online](https://pyth.herokuapp.com/?code=gsE.a&input=%5B5.86%2C+3.92%5D%2C+%5B11.8%2C+2.98%5D%0A1.670%2C+4.571)
### How it works
```
     Q   autoinitialized to eval(input())
   .a    L2 norm of vector difference of Q[0] and Q[1]
gsE      sum(eval(input()) >= that
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
ZPis<
```
Input format is:
```
[x1, y1]
[x2, y2]
[r1, r2]
```
[Try it online!](https://tio.run/##y00syfn/Pyogs9jm//9oUz0LMx0FYz1Lo1iuaENDPQsdBSM9SwsQR8/M3EBHwUTP1NwwFgA "MATL – Try It Online") Or [verify all test cases](https://tio.run/##ZY87DgIxDER7TpEDhNHa@diWKDkABRUrJCiRoIL7B2eFBFnKZ4/nyY/r694u7XS4PXdtf2xzgdYYEozPm5kIGgPDtAOqTDFkFCFHBXtwy5Ce9KktZOLEyOqHhJSLoyGxLwXSlxVMTopCS9SDE/Jfx8rtTV/3WLh2/5iHb0bx552ufgM).
### How it works
```
ZP   % Take two vectors as input. Push their Euclidean distance
i    % Input the vector of radii
s    % Sum of vector
<    % Less than?
```
[Answer]
# [R](https://www.r-project.org/), 39 bytes
```
function(k,r)dist(matrix(k,2,2))<sum(r)
```
takes input `k=c(x1,x2,y1,y2)` and `r=c(r1,r2)`; returns `FALSE` for tangent circles.
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jW6dIMyWzuEQjN7GkKLMCyDfSMdLUtCkuzdUo0vyfBhNP1jDQMdAx1jHRBCnQCdHUSdYw1jHW1PwPAA "R – Try It Online")
### 27 bytes:
```
function(m,r)dist(m)<sum(r)
```
Takes input as a matrix with the circle centers given as rows and a vector of radii.
[Try it online!](https://tio.run/##DcLBCYAwEATAdnZhH8H41C5sQCKBPC7CJYLdnzLjUfeoTy@z3R0m59XGhHEbj8EZFXZOby8KkpKyVmr5HVRBVibjAw "R – Try It Online")
[Answer]
# [Python](https://docs.python.org/2/), 40 bytes
```
lambda x,y,r,X,Y,R:abs(x-X+(y-Y)*1j)<r+R
```
[Try it online!](https://tio.run/##dc/NDoIwDAfwszzFjp2Who2PbURewpNGPWCUgEEkiFGeHsdOJuJlS9rf/u3aoS/vjRyL7DDW@e10ztkbB@xwizvcpPnpAW9/u4LB3/GluPJ1t9qMr7KqL0yk3gIc5giO86xq2mcP3Fu0XdX0rICvMD7uISadIAvJSGSCEhVwZCAEaWSSjD0jipXgR28PmqSlviQlp2ak9WRt37iqUVNCGMUOGwqt8hUpNWFHE5LC1jTF9goocnDm/d8N5kL/zJ/91@8CHw "Python 2 – Try It Online")
Uses Python's complex arithmetic to compute the distance between the two centers. I'm assuming we can't take the input points directly as complex numbers, so the code expresses them like `x+y*1j`.
[Answer]
# [Python 3](https://docs.python.org/3/), 45 bytes
```
lambda X,Y,R,x,y,r:(X-x)**2+(Y-y)**2<(R+r)**2
```
[Try it online!](https://tio.run/##FcZLCoAgFEDRrTh81vOR9o/ahCODJkVEQR@RBrl6q8m9x/p7vc40LN0Q9vGY5pEZ7FHjgx5dA0Y8PIpUDL3wP1rQsfsRrNvOGxbIqSqQpVQrZJKKMvkmqUKmqP6aUV5KzsML "Python 3 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
αs--0›
```
[Try it online!](https://tio.run/##MzBNTDJM/f//3MZiXV2DRw27/v831bMwU9BWMNazNMriMjTUswByjPQsLYAcPTNzAy4TPVNzw/@6KQA "05AB1E – Try It Online")
-1 byte by using `a - b > 0` rather than `(reverse) b - a < 0`
[Answer]
# [Python 3](https://docs.python.org/3/), 45 bytes
```
lambda a,b,c,d,e,f:(a-d)**2+(b-e)**2<(c+f)**2
```
[Try it online!](https://tio.run/##FcY5DoAgEEDRq1AOMk4EFZfoTWxAJJq4xdh4eoTm/3d/73qdZfDjFHZzWGeYQYszOlzQ92Byx7NMCbD5kjDALHxCuJ/tfMFDTa1GVlKnkEnSTREnqUWmqIutqG4k5@EH "Python 3 – Try It Online")
-8 bytes thanks to Neil/Step Hen
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 10 bytes
Prompts for circle centers as list of two complex numbers, then for radii as list of two numbers
```
(+/⎕)>|-/⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKPdvyy1KCex4L@Gtv6jvqmadjW6IBok8/9R71yFkKLSVCsuBTCAKuUy1bMw8zLWszRSMDTUs/Ay0rO04DLUMzM3UDDRMzU3RFNtoWdk5nVovZGeuRFI3hLMtjTnMtIzsbBQMNQzNjFF02GpZ2wEVGWuZ26uYKZnZAhkW@iZGgJ1WCgY6JlwcYEc5paYU4zhMiTzUdwGtAOr25BtQnMcdqchvI7sMIjngU4DAA "APL (Dyalog Unicode) – Try It Online")
`(+/⎕)` [is] the sum of the radii
`>` greater than
`|` the magnitude of
`-/⎕` the difference in centers
[Answer]
# Mathematica, 16 bytes
```
Norm[#-#2]<+##3&
```
Input: `[{x1, y1}, {x2, y2}, r1, r2]`
---
Mathematica has a `RegionIntersection` builtin, but that alone is 18 bytes long...
Built-in version:
```
RegionIntersection@##==EmptyRegion@2&
```
Takes 2 `Disk` objects. `[Disk[{x1, y1}, r1], Disk[{x2, y2}, r2]]`.
[Answer]
# [Haskell](https://www.haskell.org/), ~~37~~ 36 bytes
```
(u#v)r x y s=(u-x)^2+(v-y)^2<(r+s)^2
```
[Try it online!](https://tio.run/##dZDbqsIwEEXf@xUbfDDBdLDpJQmcfsL5AlEpWFC8IEnb0359z7T2TX2ZDTNrbvtchWt9u42jaFed9OgxIJSijXt50BvRxQPrj/CbwDo2dWgCygjYQeRkC4WUnFZIqDBbloSsgibHMaPcJJJRBWFJMxprMnoqZ/ZVd3POmak/zfIFdpQyFRsyZoIZLUgnnLGUs2wpW8D3Cd8veB/6df@Hvz4dsI@ie3V5oMS9ev4eIZ7@8mjotJaYbWLk71z7Gqc1RKs65VWvBhUkd8xmY3F7/Ac "Haskell – Try It Online")
Thanks @AndersKaseorg for `-1` byte!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
I²+⁴I²¤<⁵S²¤
```
[Try it online!](https://tio.run/##y0rNyan8/9/z0CbtR41bgNShJTaPGrcGgxj////XMNWzMNNRMDTUs9D8r2GsZ2mko2CkZwniGOqZmRvoKJjomZobagIA "Jelly – Try It Online")
-2 bytes thanks to Dennis
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 38 bytes
```
(a,b,c,x,y,z)->Math.hypot(a-x,b-y)<c+z
```
[Try it online!](https://tio.run/##lZA9b4MwEIb3/IobQTWn8GlQ2o7ZMmWsOpivhJRgBE4EVPx2elCYEiXKYN/rk97nvfNJXIUhy6Q4xT9DeQnzLIIoF3UNO5EV8LsCyAqVVKmIEthOb4BQyjwRBaRaLMmSgGCzCBcRLaJZRLuITt8Qpacz59VKKCpXmcVwplRtr6qsOHx9g6gOtT6HbiGFDxg0wUIWsYa1rNONz51QRzy2pVSaMBoWGq3@Hr11w2by7NtaJWeUF4UlIVVeaCmmmou@x8DGwGJgosfXVEz0GVgY0O2gy01df4jw0SKEYSG3Rpvj//uCqRfwkWs77hNIgDa5DY6cjxBCeGiZ1PHRpbJG5wngNvH1TW6HeHmPO/95f5F@1Q9/ "Java (OpenJDK 8) – Try It Online")
[Answer]
# Java 8, ~~41~~ 38 bytes
```
(x,y,r,X,Y,R)->Math.hypot(x-X,y-Y)<r+R
```
[Try it here.](https://tio.run/##lZBNboMwEIX3OcUsQTWj8g9K2xskC7IBVV044DakxEbgRKCKs9MhCauoSiPZ4@ex3udn7/mJW6oWcl98j3nF2xZWvJQ/C4BSatF88lzAetoCbJWqBJeQG4U6bisBHbuKfhbNLNJZZLNIzCVRBpo0Ws11mcMaJLzCaHSsZw1LWcYS03pbcb3DXV8rbXRWynorM1@ap2RcXrw14ch7RZxUWcCBIhsb3ZTy6/0DuHnJu@lbLQ6ojhprOtKVNCTmho9RwMDF2GFgYxBStTFi4GBM1UM/tM1z1j8JETpEsBwMncnmRRdffO7FExBdz78DidEltxViGE4QQgTo2NSJ0KflGb07gNsbH3/J7V88GOK/gGExjL8)
Apparently, Java also has `Math.hypot`, which is 3 bytes shorter.
EDIT: Just realized this answer is now exactly the same as [*@OlivierGrégoire*'s Java 8 answer](https://codegolf.stackexchange.com/a/136035/52210), so please upvote him instead of me if you like the 38-byte answer.
**Old answer (41 bytes)**:
```
(x,y,r,X,Y,R)->(x-=X)*x+(y-=Y)*y<(r+=R)*r
```
[Try it here.](https://tio.run/##lZDfboIwFMbvfYpz2WI5GcjfOPYG8wJvIMsuKrIFh8VANZDFZ2cHkStjnEl7@vU0369fu5MnaVaHXO22P31WyqaBd1mo3xlAoXRef8ksh9WwBdhUVZlLBRnbVsdNmUMrrqKbRD2JZBLpJGK@JMqZJo1GS11ksAIFEfSsFZ2oRSJSEXPzjbVmlHCjnbPOjFJudK@snkcxN@p@OdoPRCT7lXKqii3sKTVb67pQ3x@fIPkYed01Ot9jddR4oCNdKqYwYy4GnoAFhrYACz2fqoWBABtDqg66vsUvce8SArSJYNro24PNCUZfeOmFAxAXjvsAEuKC3KaPvj9ACOGhbVEnQJeWF3QeAG5vfP4lt3/xZIj/As6zc/8H)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 15 bytes
```
<sm^-EE2 2^+EE2
```
Takes input in the order x1,x2,y1,y2,r1,r2
[Test suite!](https://pyth.herokuapp.com/?code=%3Csm%5E-EE2+2%5E%2BEE2&input=5.86%0A11.8%0A3.92%0A2.98%0A1.670%0A4.571&test_suite=1&test_suite_input=5.86%0A11.8%0A3.92%0A2.98%0A1.67%0A4.571%0A%0A8.26%0A4.59%0A-2.72%0A-2.97%0A2.488%0A1.345%0A%0A9.32%0A6.21%0A-7.77%0A-8.51%0A2.8%0A0.4%0A%0A4.59%0A11.8%0A-2.97%0A2.98%0A1.345%0A4.571%0A%0A9.32%0A4.59%0A-7.77%0A-2.97%0A2.8%0A1.345%0A%0A5.86%0A6.21%0A3.92%0A-8.51%0A1.67%0A0.4%0A&debug=0&input_size=7)
[Answer]
# [Perl 6](http://perl6.org/), 13 bytes
```
*+*>(*-*).abs
```
[Try it online!](https://tio.run/##ZY49DoJAFIR7TjGVgVUm7LK/IXoRQqFREhMUA4XhbHZeDBEroXnJfJmZN49L19jxNmBTYz@KrTjEIhUJj6d@LNAfB9QxS1XtwNLMN6u2V8FSziL/CV0lqNsOzfV@6d8vPtvu3BejobfIGRQkrcsgJT0Ug4emcTLyVBapolMT1X7G4QuCmxK5NlFgrpA6Ojc5PCyVROppJDLqaGlfPVjEV/XLgf/9Hw "Perl 6 – Try It Online")
The first two arguments are the radii, in either order. The third and fourth arguments are the coordinates of the centers, as complex numbers, in either order.
[Answer]
# [Taxi](https://bigzaphod.github.io/Taxi/), 1582 bytes
```
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Pickup a passenger going to Tom's Trims.Pickup a passenger going to Tom's Trims.Go to Tom's Trims:n.[a]Go to Post Office:s.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to What's The Difference.Pickup a passenger going to What's The Difference.Go to What's The Difference:n 5 l.Pickup a passenger going to Cyclone.Go to Cyclone:e 1 r.Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:s 1 l 2 r 4 l.Pickup a passenger going to Addition Alley.Go to Tom's Trims:s 1 r 3 r.Pickup a passenger going to The Babelfishery.Switch to plan "b" if no one is waiting.Switch to plan "a".[b]Go to Addition Alley:n 1 r 1 l 3 l 1 l.Pickup a passenger going to Magic Eight.Go to Post Office:n 1 r 1 r 3 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Addition Alley.Pickup a passenger going to Addition Alley.Go to Addition Alley:n 5 l 1 l.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l.Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:s 1 l 2 r 4 l.Pickup a passenger going to Magic Eight.Go to Magic Eight:s 1 r.Switch to plan "c" if no one is waiting.'1' is waiting at Writer's Depot.[c]'0' is waiting at Writer's Depot.Go to Writer's Depot:w 1 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.
```
[Try it online!](https://tio.run/##1VSxbsIwEN3zFScWJiwSoNBstFSdUJFAYkAMxjjJqcaOYiPK11OHGAkIEKBTB8vy@e787t07G/qDu92nAqNgpLSBryhCxsMN@CDsyvKdjJB9r1OgkFKtuYx5BrFCGedRk4TDG11wEaFOeLa97axWdQ2TDFf6br8C3JEllGRG52XM@jGcLu@ZOdSHym9mmybU5Hhs9ACjiGdcMv5ERAHi4l0ooVPB/fuWCSUPWdwp5JXoh2thMBXIqEElYWz2@zMhxcuXLx2VgRVRu6KQ/nKJ@9C@EHx7oeV6r8VWRV2lHo83aFiSX6WCSqgtaoARSAWWJ0ANG2qflXHJj9bIbOEkdorNdsVNhUUjKqdjSGNk8IFxYkhZsYdc@8oen7Q/KfiM8oe7U6KlcwcdlwUrHWDxv0Rb7u2RpVBsSVjsigDrfv3oCNTANEPDMzsAA54qQ2ZsXm9W@LjP5MTofvKgopYjVV7VaeA0utu9klbgNbqk2/UC0vNeSOB7jR7p@F6TtH8B)
Outputs `1` for overlapping circles.  
Outputs `0` for non-overlapping circles (including tangential circles).
Ungolfed / formatted:
```
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Pickup a passenger going to Tom's Trims.
Pickup a passenger going to Tom's Trims.
Go to Tom's Trims: north.
[a]
Go to Post Office: south.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to What's The Difference.
Pickup a passenger going to What's The Difference.
Go to What's The Difference: north 5th left.
Pickup a passenger going to Cyclone.
Go to Cyclone: east 1st right.
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station: south 1st left 2nd right 4th left.
Pickup a passenger going to Addition Alley.
Go to Tom's Trims: south 1st right 3rd right.
Pickup a passenger going to The Babelfishery.
Switch to plan "b" if no one is waiting.
Switch to plan "a".
[b]
Go to Addition Alley: north 1st right 1st left 3rd left 1st left.
Pickup a passenger going to Magic Eight.
Go to Post Office: north 1st right 1st right 3rd right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Addition Alley.
Pickup a passenger going to Addition Alley.
Go to Addition Alley: north 5th left 1st left.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left.
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station: south 1st left 2nd right 4th left.
Pickup a passenger going to Magic Eight.
Go to Magic Eight: south 1st right.
Switch to plan "c" if no one is waiting.
'1' is waiting at Writer's Depot.
[c]
'0' is waiting at Writer's Depot.
Go to Writer's Depot: west 1st left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
```
[Answer]
# C#, ~~50~~ 41 bytes
```
(x,y,r,X,Y,R)=>(x-=X)*x+(y-=Y)*y<(r+=R)*r
```
*Saved 9 bytes thanks to @KevinCruijssen.*
[Answer]
# [Scala](http://www.scala-lang.org/), 23 bytes
Thanks @Arnauld for [his *almost polyglot* answer](https://codegolf.stackexchange.com/a/135971/71499).
```
math.hypot(a-x,b-y)<r+q
```
[Try it online!](https://tio.run/##jZDNToNAFIXX8hQ3XTHpcNOZ8jM0aqJx6xMYF0M7pjXIUIoG0vTZcbh0EjUs3MAJ@b5zmDltdakHW7ybbQvP@lCB6VpT7U7wUNfn4GZn3sB@mabUdag3T/azKA3vfCh86H1ofDheA9s8WlsaXd2dhw/d7nHf17YNddTxIurZbbM8DpcgqJtD1ZZVuHgJE1QphzXmkoPANFsxDqEQqDhIzN0zxiQT7BWie1gs/c@RRRSZRI42n2j2c0GhdAuRxEyOnbFS44QDc/qaZ@PwOk7@bpBH2OROLBXwSfg1M1P4n5OQRpTvz6/1c2eZva0UpXDLChP3WmE8e1kEkTiBZPORZsFl@AY "Scala – Try It Online")
[Answer]
# PostgreSQL, 41 characters
```
prepare f(circle,circle)as select $1&&$2;
```
Prepared statement, takes input as 2 parameters in any [`circle` notation](https://www.postgresql.org/docs/current/static/datatype-geometric.html#DATATYPE-CIRCLE).
Sample run:
```
Tuples only is on.
Output format is unaligned.
psql (9.6.3, server 9.4.8)
Type "help" for help.
psql=# prepare f(circle,circle)as select $1&&$2;
PREPARE
psql=# execute f('5.86, 3.92, 1.670', '11.8, 2.98, 4.571');
t
psql=# execute f('8.26, -2.72, 2.488', '4.59, -2.97, 1.345');
t
psql=# execute f('9.32, -7.77, 2.8', '6.21, -8.51, 0.4');
t
psql=# execute f('4.59, -2.97, 1.345', '11.8, 2.98, 4.571');
f
psql=# execute f('9.32, -7.77, 2.8', '4.59, -2.97, 1.345');
f
psql=# execute f('5.86, 3.92, 1.670', '6.21, -8.51, 0.4');
f
```
[Answer]
## Java, ~~50~~ 38 bytes
```
(x,y,r,X,Y,R)->Math.hypot(x-X,y-Y)<r+R
```
[Answer]
# x86 Machine Code (with SSE2), 36 bytes
```
; bool CirclesOverlap(double x1, double y1, double r1,
;                     double x2, double y2, double r2);
F2 0F 5C C3        subsd   xmm0, xmm3      ; x1 - x2
F2 0F 5C CC        subsd   xmm1, xmm4      ; y1 - y2
F2 0F 58 D5        addsd   xmm2, xmm5      ; r1 + r2
F2 0F 59 C0        mulsd   xmm0, xmm0      ; (x1 - x2)^2
F2 0F 59 C9        mulsd   xmm1, xmm1      ; (y1 - y2)^2
F2 0F 59 D2        mulsd   xmm2, xmm2      ; (r1 + r2)^2
F2 0F 58 C1        addsd   xmm0, xmm1      ; (x1 - x2)^2 + (y1 - y2)^2
66 0F 2F D0        comisd  xmm2, xmm0
0F 97 C0           seta    al              ; ((r1 + r2)^2) > ((x1 - x2)^2 + (y1 - y2)^2)
C3                 ret
```
The above function accepts descriptions of two circles (x- and y-coordinates of center point and a radius), and returns a Boolean value indicating whether or not they intersect.
It uses a vector calling convention, where the parameters are passed in SIMD registers. On x86-32 and 64-bit Windows, this is the [`__vectorcall` calling convention](https://en.wikipedia.org/wiki/X86_calling_conventions#Microsoft_vectorcall). On 64-bit Unix/Linux/Gnu, this is the standard [System V AMD64 calling convention](https://en.wikipedia.org/wiki/X86_calling_conventions#System_V_AMD64_ABI).
The return value is left in the low byte of `EAX`, as is standard with all x86 calling conventions.
This code works equally well on 32-bit and 64-bit x86 processors, as long as they support the [SSE2 instruction set](https://en.wikipedia.org/wiki/SSE2) (which would be Intel Pentium 4 and later, or AMD Athlon 64 and later).
### AVX version, still 36 bytes
If you were targeting [AVX](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions), you would probably want to add a VEX prefix to the instructions. This does not change the byte count; just the actual bytes used to encode the instructions:
```
; bool CirclesOverlap(double x1, double y1, double r1,
;                     double x2, double y2, double r2);
C5 FB 5C C3      vsubsd   xmm0, xmm0, xmm3   ; x1 - x2
C5 F3 5C CC      vsubsd   xmm1, xmm1, xmm4   ; y1 - y2
C5 EB 58 D5      vaddsd   xmm2, xmm2, xmm5   ; r1 + r2
C5 FB 59 C0      vmulsd   xmm0, xmm0, xmm0   ; (x1 - x2)^2
C5 F3 59 C9      vmulsd   xmm1, xmm1, xmm1   ; (y1 - y2)^2
C5 EB 59 D2      vmulsd   xmm2, xmm2, xmm2   ; (r1 + r2)^2
C5 FB 58 C1      vaddsd   xmm0, xmm0, xmm1   ; (x1 - x2)^2 + (y1 - y2)^2
C5 F9 2F D0      vcomisd  xmm2, xmm0
0F 97 C0         seta     al                 ; ((r1 + r2)^2) > ((x1 - x2)^2 + (y1 - y2)^2)
C3               ret
```
AVX instructions have the advantage of taking *three* operands, allowing you to do non-destructive operations, but that doesn't really help us to compact the code any here. However, mixing instructions with and without VEX prefixes can result in sub-optimal code, so you generally want to stick with *all* AVX instructions if you're targeting AVX, and in this case, it doesn't even hurt your byte count.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes
```
-¨nOt²¹+θ‹
```
[Try it online!](https://tio.run/##MzBNTDJM/f9f99CKPP@SQ5sO7dQ@t@NRw87//6NN9SzMdBSM9SyNdBQM9czMDWK5og0N9Sx0FIz0LIGkiZ6puWEsAA "05AB1E – Try It Online")
[Answer]
# [PHP](https://php.net/), 66 bytes
```
<?php $i=$argv;echo hypot($i[1]-$i[4],$i[2]-$i[5])<$i[3]+$i[6]?:0;
```
[Try it online!](https://tio.run/##HcZBCoMwEEbhq7jIosV2cKKJsSoeRGYhRYyrDCJCT/83uPne06jAMGnUwuyjWY7t6tdvTEX8aTofZp9Z3tlGXll7v5PnkFNLmfUyfaoegKPgUVNnweTbCswUYKkLaMi1/Ac "PHP – Try It Online")
Runs from the command line, taking input as 6 command-line parameter arguments, and prints 1 if the circles overlap, else 0.
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 22 bytes
```
9k?+_5R-d*_3R-d*+v-vzp
```
[Try it online!](https://tio.run/##S0n@/98y21473jRIN0Ur3hhEapfpllUV/P9vqmdhpmBoqGehYKxnaaRgpGdpoWCoZ2ZuoGCiZ2puCAA "dc – Try It Online")
[Or try the test suite!](https://tio.run/##RY7BboMwEETv/ooRyqmIbWwwtqUoPbXXSPkBiwItUZMQ0Tat@vPEXiCVpd3Vembevlaf3VhXX9jiMvTvQ3XCZoPkefeSjO7jKfV6nzUPPo81vWbXv8sY/kTdnfoG3@nv4hI/3eHYYmirBsfDuRVA04cSWo3sDfT4Hx/yV1GTsOjcjppsCSnJIienoMhZSCrNGgVpIyEsqTLODl6RUbE6E3SFjcK80BCOcoWSlIQ3ZAy8JS2DxGJNBQSbGbF43WKdGRwwMaaAWXcn8JVM4CsnwHQmI0LjF5Y8q3m@AQ)
Input is read from stdin in the format `x1 x2 y1 y2 r1 r2`. Note that negative numbers are written in dc with an underscore `_` instead of a minus sign `-`.
Output is on stdout: 1 for truthy, 0 for falsey. If the two circles are tangent to one another or if they're identical, they're considered to be overlapping.
---
This requires a recent version of GNU dc which supports the `R` operation (rotate).
On versions of dc which don't support `R`, you can instead use
`9k?-d*sY-d*lY+vsD+lD-vzp`
(24 bytes long), with input presented on stdin in the order `r1 r2 x1 x2 y1 y2`. Here's a [test suite for the 24-byte program, for older versions of dc](https://tio.run/##RY7NTsMwEITvfopR1BNRtvHmx7ZUwaVw5dxTFJKUVKRNlUBBvHxw1gJkabzSzsy3L/XcL039jntcp/F1qs/Y7RA9Pj9Fi3t7SNq7@eBlOMS3eR8P@@T2fV38VjX9eWzxEX/95tRnfxo6TF3dYjhdOgW0oxf/NUiOoO0/wBM2qycS06VbNJUmRU6F0SjIltCaLDJyDCZnFVNuLTRleQFLXK5Wh4rJ8KrOeIdFSjkcZYySWKMyZAwqS4WGCtEAkKwAJCoESEFwSUUAhAoBhBNXhBwoCDlQCEpDIw3vb2Y//wA)
---
**Explanation**
```
9k   Set precision to 9 decimal places.
?    Read the input and push all 6 numbers on the stack (r2 is at the top of the stack since it's entered last).
+    Add r1 and r2
_5R  Rotate the stack so that r1+r2 is now at the bottom.
-d*  Compute (y1-y2)^2.
_3R  Rotate the stack so that it's now: r1+r2 (y1-y2)^2 x1 x2 (top on the right)
-d*  Compute (x1-x2)^2.
+    Compute (x1-x2)^2 + (y1-y2)^2.
v    Take the square root to compute the distance between the centers.
-    Subtract the distance between the centers from r1-r2.
v    Pop one number from the stack. If it's non-negative, then compute its square root and push that back on the stack.
z    Push the size of the stack onto the stack. (This is 0 if the difference was negative, and it's 1 if the difference was positive.)
p    Print the item at the top of the stack.
```
[Answer]
## Julia 0.6.0 (46 bytes)
```
a->((a[1]-a[2])^2+(a[3]-a[4])^2<(a[5]+a[6])^2)
```
[Answer]
# Clojure, 68 bytes
```
#(<(+(*(- %4 %)(- %4 %))(*(- %5 %2)(- %5 %2)))(*(+ %6 %3)(+ %6 %3)))
```
Takes six arguments: x1, y1, r1, x2, y2, r2. Returns true or false.
Sadly, Clojure does not have a `pow` function of some sorts. Costs a lot of bytes.
[Answer]
# [Actually](https://github.com/Mego/Seriously), 8 bytes
```
-)-(h@+>
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/19XU1cjw0Hb7v9/Ez1Tc0MFZYUiIy5DPTNzAxDTkMvQUM8CyKow4jLVszADsQy5jPQsQWKVRlzGepZGIJYhAA "Actually – Try It Online")
Explanation:
```
-)-(h@+>  (implicit input: [y1, y2, x1, x2, r1, r2])
-         y2-y1 ([y2-y1, x1, x2, r1, r2])
 )-       move to bottom, x1-x2 ([x1-x2, r1, r2, y2-y1])
   (h     move from bottom, Euclidean norm ([sqrt((y2-y1)**2+(x2-x1)**2), r1, r2])
     @+   r1+r2 ([r1+r2, norm])
       >  is r1+r2 greater than norm?
```
[Answer]
# R (+pryr), 31 bytes
```
pryr::f(sum((x-y)^2)^.5<sum(r))
```
Which evaluates to the function
```
function (x, y, z) 
sum((x - y)^2)^0.5 < sum(z)
```
Where `x` are the coordinates of circle 1, `y` are the coordinates of circle 2 and `z` the radii.
Calculates the distance between the two centers using Pythagoras and tests if that distance is smaller than the sum of the radii.
Makes use of R's vectorisation to simultaneously calculate `(x1-x2)^2` and `(y1-y2)^2`. These are then summed and squarely rooted.
]