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