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