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