When casting the spell Reincarnate (PHB pg.271), does the target retain the ability score bonuses of their previous race?

# Tag: after

## I want to know where to share posts after published

Hello Guys

Happy New Year!

I want to know where to share the link of your blog post or say post, so a little bit of traffic can be obtained on the post, especially when you suck at having bad networking skills.

Please also tell if there is any area on DigitalPoint, where I just can post my blog posts and don't get banned like on Reddit etc.

Thanks & Regards

Raj Kumar

## Is the value of “damage dealt/taken” calculated after resistances?

The basic rules say about damage resistance/vulnerability:

Resistance and then vulnerability are applied after all other modifiers to damage. For example, a creature has resistance to bludgeoning damage and is hit by an attack

that deals 25 bludgeoning damage. The creature is also within a magical aura that reduces all damage by 5. The 25 damage is first reduced by 5 and then halved, sothe creature takes 10 damage.

The attack deals 25 damage, but the creature took 10 damage. **Can I consider that the attack then dealt only 10 damage?**

This came up with my Wizard, who has Vampiric Touch:

On a hit, the target takes 3d6 necrotic damage, and you regain hit points equal to half the amount of necrotic damage dealt.

and Life Transference (XGtE, p. 160):

You take 4d8 necrotic damage, and one creature of your choice that you can see within range regains a number of hit points equal to twice the necrotic damage you take.

We wonder what happens when the target has resistance or immunity to Necrotic damage. Is the HP gain calculated after the damage is resisted?

Related questions:

- Is Resistance/Vulnerability applied before or after Cutting Words?
- If someone casts Vampiric Touch on a creature with necrotic absorption, does the caster take damage?

## the view is not returning after calling synthesizer.SpeakAsync(value)

`public async Task<ActionResult> UpdateCounter(Counter counter) { using (CounterAppForANTHEntities1 entities = new CounterAppForANTHEntities1()) { Counter updatedCustomer = (from c in entities.Counters where c.id == 1 select c).FirstOrDefault(); updatedCustomer.Counter_value = updatedCustomer.Counter_value+1; int res = updatedCustomer.Counter_value; entities.SaveChanges(); SpeechSynthesizer synthesizer = new SpeechSynthesizer(); string value= "Token Number"+IntToString(res); synthesizer.SpeakAsync(value); return View(updatedCustomer); } return RedirectToAction("Index"); } `

I want to show the updated view after this speak

## Possible public/private identity recovery after compromise without a centeral authority?

I’ve been thinking about P2P systems using asymmetric keys and wondering if there is anyway to recover an identity in the event it was compromised using some kind of web-of-trust.

This seems to be a large issue compared to a regular system (using a central authority) that can remove the intruder’s access and restore control of the account to the real owner (Digicert, facebook, twitter, etc…).

What if a master key was generated and used to create a subkey. Then using 16+ random bytes the master keys private component could be encrypted. The owner could choose 5+ nodes on the network (friends?) to store parts of the secret and erase it’s knowledge of those bytes.

The subkey would be the user identity (with it’s own AES password protecting the private part). Should this client get phished, forget their password, or someone steal their sub-key private component, we could use the peers to restore the master key and revoke this subkey.

I’m not sure how this would work other than the client sending a request to each node and them verifying the client though some out-of-bands way (phone call? Text?) before sending their part of the master key password.

Would this work? Are their any existing solutions to this problem?

## After running through my algorithm fine, my array returns as all zeros

I’ve spent a long time finally getting my algorithm in Python to invert Laplace transforms and live plot them to work, but unfortunately, although it seems to run fine within the function, it continuously just plots zeros!

I’ve wasted so much time getting this thing to work, and now I have no clue what could be wrong. So forgive me but I think I’ll have to post the whole thing.

The equation this is based on is a series-integral and it iterates until the series converges. However, it converges super slowly so I used Aitken’s delta-squared method to speed the whole thing up. The goal is to populate array `y`

with each Aitken’s iteration from 0.000001 to 10 and then compare the estimation’ integral with the previous iteration’s if a random point in the former is close enough to the latter. This loops until the integrals have a difference of less than 0.01 or a set amount of iterations is reached (~30000).

This happens for 6 equations simultaneously using parallel processing. The graph live plots all 6 (in blue) compared to each of the actual equations they’re converging towards (in red) using matplotlib.

For debugging, I basically tried putting a bunch of print statements everywhere in the `f_u`

function to see what was going on. Everything looked like it was going fine. But in the `__main__`

function and `plot`

functions when I did the same, I was getting all zeros for the same array. I thought it was a local vs. global issue so I put `global y`

in the `plot`

and `f_u`

, with no luck.

I know this isn’t doing this due to the parallelization; I tried without it with no luck. Basically, I suggest looking at what `y`

does between the `f_u`

function and the `__main__`

function, thats where the relationship with the y arrays breaks down I think, I just don’t know what to do to fix it.

To execute this, you’re gonna need all the packages in the import statement, including numba. You can remove the `@jit`

decorations on the Laplace functions if you don’t want numba, but it will be sloooooow.

Here it is:

`import matplotlib.pyplot as plt from matplotlib import style from matplotlib import animation import numpy as np from scipy.integrate import quad, simps from scipy.special import jv import math import random import datetime import multiprocessing as mp from numba import jit start = datetime.datetime.now() # Record time start # Initialize plot style.use('fivethirtyeight') fig, axes = plt.subplots(3, 2) ((ax1, ax2), (ax3, ax4), (ax5, ax6)) = axes plt.autoscale(enable=True) for ax in axes.flat: ax.label_outer() # Initialize variables gamma = np.array([np.nan, 1, 1, 0, 1.5, 2, 1]) # Bromwich contour parameter for each equation num = 6 # Number of equations to be processed in total n = 0 # Repetition constant for equation 3, set to either zero or 1 (diverges at 1) max_count = 1000 # Number of data points in x and y epsilon = 10 ** -40 # Minimum number to divide by in Aitken's iteration err = 10 ** -4 # Maximum difference in y to trigger comparison in closing() max_err = 0.01 # Maximum difference in integrals computed in closing() to end iteration process x_0 = 0 # Set first integral to 0 for now result = np.zeros(7) # Vector to store Aitken's iteration for closing() comparison previous = np.zeros(7) # Vector to store iteration before Aitken's for closing() comparison end = np.zeros(7) # Vector to store end conditions -- running = 0, ended = 1 u, step = np.linspace(0.000001, 10, max_count, retstep=True) # Initializing x values y = np.empty([num, 4, max_count]) # Initializing y values -- form is y[equation number][iteration in Aitken's][x value] y_denom = np.empty([num, max_count]) # Initializing array to store Aitken's denominator values for each equation x_iter = np.empty([num, max_count]) # Initializing array to store Aitken's iteration as starting point for next iteration def printer(num, k): # Prints the equation number, iteration and y value at 10 if num == 1: print(str(num) + " " + str(k) + " " + str(y[0][3][max_count-1]) + "\n") elif num == 2: print(str(num) + " " + str(k) + " " + str(y[1][3][max_count-1]) + "\n") elif num == 3: print(str(num) + " " + str(k) + " " + str(y[2][3][max_count-1]) + "\n") elif num == 4: print(str(num) + " " + str(k) + " " + str(y[3][3][max_count-1]) + "\n") elif num == 5: print(str(num) + " " + str(k) + " " + str(y[4][3][max_count-1]) + "\n") elif num == 6: print(str(num) + " " + str(k) + " " + str(y[5][3][max_count-1]) + "\n") def plot1(): # Plots estimation 1 (blue) and actual equation 1 (red) global y ax1.clear() line1, = ax1.plot(u, y[0][3][0:max_count]) ax1.plot(u, np.sin(u), 'tab:red') return line1, def plot2(): # Plots estimation 2 (blue) and actual equation 2 (red) global y ax2.clear() line2, = ax2.plot(u, y[1][3][0:max_count]) ax2.plot(u, np.heaviside(u, 1), 'tab:red') return line2, def plot3(): # Plots estimation 3 (blue) and actual equation 3 (red) global y ax3.clear() line3, = ax3.plot(u, y[2][3][0:max_count]) ax3.plot(u, np.cos(2 * np.sqrt(u)) / np.sqrt(np.pi * u), 'tab:red') return line3, def plot4(): # Plots estimation 4 (blue) and actual equation 4 (red) global y ax4.clear() line4, = ax4.plot(u, y[3][3][0:max_count]) ax4.plot(u, np.log(u), 'tab:red') return line4, def plot5(): # Plots estimation 5 (blue) and actual equation 5 (red) global y ax5.clear() line5, = ax5.plot(u, y[4][3][0:max_count]) ax5.plot(u, np.heaviside(u - 1, 1) - np.heaviside(u - 2, 1), 'tab:red') return line5, def plot6(): # Plots estimation 6 (blue) and actual equation 6 (red) global y ax6.clear() line6, = ax6.plot(u, y[5][3][0:max_count]) ax6.plot(u, jv(0, u), 'tab:red') return line6, def animate(i): # Plots all equations, used to live-update graph ln1, = plot1() ln2, = plot2() ln3, = plot3() ln4, = plot4() ln5, = plot5() ln6, = plot6() return ln1, ln2, ln3, ln4, ln5, ln6, @jit(nopython=True, cache=True) def f_p1(omega, u, k): # Equation 1, Laplace form b = (omega + k * np.pi) / u a = gamma[1] f1 = a * (1 / (a ** 2 + (b + 1) ** 2) + 1 / (a ** 2 + (b - 1) ** 2)) * np.cos(omega) return f1 @jit(nopython=True, cache=True) def f_p2(omega, u, k): # Equation 2, Laplace form b = (omega + k * np.pi) / u a = gamma[2] f2 = a / (a ** 2 + b ** 2) * np.cos(omega) return f2 @jit(nopython=True, cache=True) def f_p3(omega, u, k): # Equation 3, Laplace form b = (omega + k * np.pi) / u a = gamma[3] f3 = np.e ** (-a / (a ** 2 + b ** 2)) * (a ** 2 + b ** 2) ** (1 / 4) * np.cos( (math.atan2(b, a) + 2 * n * np.pi) / 2) * np.cos(b / (a ** 2 + b ** 2)) / ( np.sqrt(a ** 2 + b ** 2) * (np.cos((math.atan2(b, a) + 2 * n * np.pi) / 2) ** 2 + np.sin( (math.atan2(b, a) + 2 * n * np.pi) / 2))) * np.cos(omega) return f3 @jit(nopython=True, cache=True) def f_p4(omega, u, k): # Equation 4, Laplace form b = (omega + k * np.pi) / u a = gamma[4] f4 = -(a * np.log(a ** 2 + b ** 2) + a * np.e) / (a ** 2 + b ** 2) * np.cos(omega) return f4 @jit(nopython=True, cache=True) def f_p5(omega, u, k): # Equation 5, Laplace form b = (omega + k * np.pi) / u a = gamma[5] f5 = a * (np.e ** (-a) * np.cos(b) - np.e ** (-2 * a) * np.cos(2 * b)) / (a ** 2 + b ** 2) * np.cos(omega) return f5 @jit(nopython=True, cache=True) def f_p6(omega, u, k): # Equation 6, Laplace form b = (omega + k * np.pi) / u a = gamma[6] f6 = np.sqrt((a ** 2 - b ** 2 + 1) ** 2 + (2 * a * b) ** 2) * np.cos( (math.atan2(2 * a * b, a ** 2 - b ** 2 + 1) + 2 * n * np.pi) / 2) / ( ((a ** 2 - b ** 2 + 1) ** 2 + (2 * a * b) ** 2) * ( np.cos((math.atan2(2 * a * b, a ** 2 - b ** 2 + 1) + 2 * n * np.pi) / 2) ** 2 + np.sin( (math.atan2(2 * a * b, a ** 2 - b ** 2 + 1) + 2 * n * np.pi) / 2) ** 2)) * np.cos(omega) return f6 def closing(result, previous, num, k): # Checks for convergence. If so, adds each term to f_0 and ends process if abs(result - previous) < max_err: diff = abs(result - previous) print("Equation " + str(num) + " converges to " + str(diff) + " with " + str(k) + " iterations." + "\n") if num == 1: for i in range(max_count): y[0][3][i] += f_0(num, i) end[1] += 1 return 1 elif num == 2: for i in range(max_count): y[1][3][i] += f_0(num, i) end[2] += 1 return 1 elif num == 3: for i in range(max_count): y[2][3][i] += f_0(num, i) end[3] += 1 return 1 elif num == 4: for i in range(max_count): y[3][3][i] += f_0(num, i) end[4] += 1 return 1 elif num == 5: for i in range(max_count): y[4][3][i] += f_0(num, i) end[5] += 1 return 1 elif num == 6: for i in range(max_count): y[5][3][i] += f_0(num, i) end[6] += 1 return 1 else: print("Equation " + str(num) + " has not yet converged.\n") return 0 def f_0(num, i): # Initial integral in the series. Added at end after closing() convergence test if num == 1: x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad( f_p1, 0, np.pi / 2, args=(u[i], 0))[0] elif num == 2: x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad( f_p2, 0, np.pi / 2, args=(u[i], 0))[0] elif num == 3: x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad( f_p3, 0, np.pi / 2, args=(u[i], 0))[0] elif num == 4: x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad( f_p4, 0, np.pi / 2, args=(u[i], 0))[0] elif num == 5: x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad( f_p5, 0, np.pi / 2, args=(u[i], 0))[0] elif num == 6: x_0 = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * quad( f_p6, 0, np.pi / 2, args=(u[i], 0))[0] return x_0 def f_u(u, num): # Main algorithm. Here, the summation integrals iterate global y, result, previous # Forces retrieval of from global of these arrays? (attempt to debug) k = 1 # Number of iterations for i in range(max_count): # First overall series iteration (initial 1st) if num == 1: y[0][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p1, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 2: y[1][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p2, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 3: y[2][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p3, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 4: y[3][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p4, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 5: y[4][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p5, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 6: y[5][0][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p6, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] for j in range(10000): # Iteration loop. Goes until closing() or k = ~30000 for each equation if j > 0: for i in range(max_count): # Sets the first iteration (out of 3 for Aitken's) equal to the previous Aitken's or the first iteration if j = 0 (1st) if num == 1: y[0][0][i] = x_iter[0][i] elif num == 2: y[1][0][i] = x_iter[1][i] elif num == 3: y[2][0][i] = x_iter[2][i] elif num == 4: y[3][0][i] = x_iter[3][i] elif num == 5: y[4][0][i] = x_iter[4][i] elif num == 6: y[5][0][i] = x_iter[5][i] else: k += 1 for i in range(max_count): # Second iteration for Aitken's (2nd) if num == 1: y[0][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p1, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 2: y[1][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p2, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 3: y[2][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p3, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 4: y[3][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p4, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 5: y[4][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p5, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 6: y[5][1][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p6, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] k += 1 for i in range(max_count): # Third iteration for Aitken's (3rd) if num == 1: y[0][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p1, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 2: y[1][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p2, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 3: y[2][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p3, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 4: y[3][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p4, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 5: y[4][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p5, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] elif num == 6: y[5][2][i] = 2 * np.e ** (gamma[num] * u[i]) / (np.pi * u[i]) * (-1) ** k * quad( f_p6, -np.pi / 2, np.pi / 2, args=(u[i], k))[0] k += 1 for i in range(max_count): # Aitken's delta-squared method iteration using the previous 3 (4th) if num == 1: y_denom[0][i] = (y[0][2][i] - y[0][1][i]) - (y[0][1][i] - y[0][0][i]) if abs(y_denom[0][i]) < epsilon: print("Denominator too small to calculate. Exiting...\n") return 9 y[0][3][i] = y[0][2][i] - ((y[0][2][i] - y[0][1][i]) ** 2) / y_denom[0][i] elif num == 2: y_denom[1][i] = (y[1][2][i] - y[1][1][i]) - (y[1][1][i] - y[1][0][i]) if abs(y_denom[1][i]) < epsilon: print("Denominator too small to calculate. Exiting...\n") return 9 y[1][3][i] = y[1][2][i] - ((y[1][2][i] - y[1][1][i]) ** 2) / y_denom[1][i] elif num == 3: y_denom[2][i] = (y[2][2][i] - y[2][1][i]) - (y[2][1][i] - y[2][0][i]) if abs(y_denom[2][i]) < epsilon: print("Denominator too small to calculate. Exiting...\n") return 9 y[2][3][i] = y[2][2][i] - ((y[2][2][i] - y[2][1][i]) ** 2) / y_denom[2][i] elif num == 4: y_denom[3][i] = (y[3][2][i] - y[3][1][i]) - (y[3][1][i] - y[3][0][i]) if abs(y_denom[3][i]) < epsilon: print("Denominator too small to calculate. Exiting...\n") return 9 y[3][3][i] = y[3][2][i] - ((y[3][2][i] - y[3][1][i]) ** 2) / y_denom[3][i] elif num == 5: y_denom[4][i] = (y[4][2][i] - y[4][1][i]) - (y[4][1][i] - y[4][0][i]) if abs(y_denom[4][i]) < epsilon: print("Denominator too small to calculate. Exiting...\n") return 9 y[4][3][i] = y[4][2][i] - ((y[4][2][i] - y[4][1][i]) ** 2) / y_denom[4][i] elif num == 6: y_denom[5][i] = (y[5][2][i] - y[5][1][i]) - (y[5][1][i] - y[5][0][i]) if abs(y_denom[5][i]) < epsilon: print("Denominator too small to calculate. Exiting...\n") return 9 y[5][3][i] = y[5][2][i] - ((y[5][2][i] - y[5][1][i]) ** 2) / y_denom[5][i] k += 1 printer(num, k) rand = random.randrange(0, max_count) # Setting random number for x value # Comparison between y at random x in Aitken's vs the previous iteration. If close enough, triggers closing() if num == 1: if abs(y[0][3][rand] - y[0][2][rand]) < err: result[num] = simps(y[0][3][0:max_count], u, dx=step) #Integrates Aitken's iteration (4th) previous[num] = simps(y[0][2][0:max_count], u, dx=step) #Integrates integration before Aitken's (3rd) c1 = closing(result[num], previous[num], num, k) if c1 == 1: break elif num == 2: if abs(y[1][3][rand] - y[1][2][rand]) < err: result[num] = simps(y[1][3][0:max_count], u, dx=step) previous[num] = simps(y[1][2][0:max_count], u, dx=step) c2 = closing(result[num], previous[num], num, k) if c2 == 1: break elif num == 3: if abs(y[2][3][rand] - y[2][2][rand]) < err: result[num] = simps(y[2][3][0:max_count], u, dx=step) previous[num] = simps(y[2][2][0:max_count], u, dx=step) c3 = closing(result[num], previous[num], num, k) if c3 == 1: break elif num == 4: if abs(y[3][3][rand] - y[3][2][rand]) < err: result[num] = simps(y[3][3][0:max_count], u, dx=step) previous[num] = simps(y[3][2][0:max_count], u, dx=step) c4 = closing(result[num], previous[num], num, k) if c4 == 1: break elif num == 5: if abs(y[4][3][rand] - y[4][2][rand]) < err: result[num] = simps(y[4][3][0:max_count], u, dx=step) previous[num] = simps(y[4][2][0:max_count], u, dx=step) c5 = closing(result[num], previous[num], num, k) if c5 == 1: break elif num == 6: if abs(y[5][3][rand] - y[5][2][rand]) < err: result[num] = simps(y[5][3][0:max_count], u, dx=step) previous[num] = simps(y[5][2][0:max_count], u, dx=step) c6 = closing(result[num], previous[num], num, k) if c6 == 1: break for i in range(max_count): # Setting current Aitken's iteration to first iteration if num == 1: x_iter[0][i] = y[0][3][i] elif num == 2: x_iter[1][i] = y[1][3][i] elif num == 3: x_iter[2][i] = y[2][3][i] elif num == 4: x_iter[3][i] = y[3][3][i] elif num == 5: x_iter[4][i] = y[4][3][i] elif num == 6: x_iter[5][i] = y[5][3][i] # If iteration limit reached, sets process closing condition to 1 and returns to main end[num] = 1 return if __name__ == '__main__': i = 0 # Define and begin processes, one for each equation p1 = mp.Process(target=f_u, args=(u, 1)) p2 = mp.Process(target=f_u, args=(u, 2)) p3 = mp.Process(target=f_u, args=(u, 3)) p4 = mp.Process(target=f_u, args=(u, 4)) p5 = mp.Process(target=f_u, args=(u, 5)) p6 = mp.Process(target=f_u, args=(u, 6)) p1.start() p2.start() p3.start() p4.start() p5.start() p6.start() # While any equation is running, update and show the plot every second while end[1] != 1 or end[2] != 1 or end[3] != 1 or end[4] != 1 or end[5] != 1 or end[6] != 1: animation.FuncAnimation(fig, animate, interval=1000, blit=True) plt.pause(1) plt.show(block=False) plt.pause(1) # Joining and closing each process when complete p1.join() p1.terminate() p2.join() p2.terminate() p3.join() p3.terminate() p4.join() p4.terminate() p5.join() p5.terminate() p6.join() p6.terminate() end = datetime.datetime.now() # Record time end print("Runtime: " + str(end - start)) # Updates and plots final result animate(i) plt.show() exit(0) `

Hope you can help me out. Thanks in advance.

## About “dropping” a weapon after an attack

Let’s say that after making an attack with my lance by stabbing it into an enemy, I leave the lance there (stab it into the enemy and just let go). Is this considered *dropping the lance*? And as such, am I able to take out my longsword and attack with it (Fighter lvl 6 has the *Extra Attack* class feature).

## WordPress hook after post content and meta update

I want to update one of my meta field and redirect and I am using `post_updated`

hook. Here is my code.

`function job_publish_status( $ post_ID, $ post_after, $ post_before ) { $ job_published_date = get_the_time("Y-m-d", $ post_ID); $ expire_date = date('Y-m-d', strtotime($ job_published_date. ' + 60 days')); update_post_meta($ post_ID, '_job_expires', $ expire_date); $ url = get_site_url(); $ url = $ url.'/wp-admin/post.php?post='.$ post_ID.'&action=edit'; wp_redirect( $ url ); exit; } add_action('post_updated', 'job_publish_status', 99, 3 ); `

It is updating this `_job_expires`

meta field and redirecting correctly. When I edit post content and title, its updates title and content but it is not updating other meta fields in this post. Is there any hook which triggers after post content update and meta fields update ?

## Why multiple rotations might be needed after deletion in an AVL tree if after insertion there can be at most one needed?

I understand that after deletion you have to retrace to update ancestors and after insertion you do the similar however at most one rotation will be performed.

The question is why is there the difference in number of potential rotations for these two operations.

To me it seems like these operations should be the reverse of each other but this difference in their properties suggests they’re not. Why?

## attach with gdb after dropping privileges

Under Ubuntu 16.04 LTS, I cannot seem to debug a once-privileged process for love or money as an unprivileged user.

The file is setgid (mode 2755). It forks, and the child:

- releases its capabilities
- calls
`setgid(getgid())`

Yet, gdb cannot attach to it when running under the same uid and gid.

`$ cat /proc/sys/kernel/yama/ptrace_scope 0 $ echo $ (id -nu) $ (id -ng) jklowden jklowden $ ps -p 18272 -o user,group,euser,egroup USER GROUP EUSER EGROUP jklowden jklowden jklowden jklowden $ gdb -q -p 18272 Attaching to process 18272 Could not attach to process. If your uid matches the uid of the target process, check the setting of /proc/sys/kernel/yama/ptrace_scope, or try again as the root user. For more details, see /etc/sysctl.d/10-ptrace.conf ptrace: Operation not permitted. `

What am I missing?

I have also tried to attack this by raising my own capabilities, with some success, although I’m not sure it’s the “right” answer.

`$ cat /etc/security/capability.conf CAP_SYS_PTRACE jklowden $ sudo setcap CAP_SYS_PTRACE=pe $ (which gdb) `

That allows gdb to attach to the process. But it does so by increasing what gdb can do, not decreasing what the process requires.

In case it’s interesting, the file’s setgid id is not root, but an unprivileged group that gives it access to a group-writable directory. Users of the application similarly belong to the same group, but forked child processes don’t require access to that directory.