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