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