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