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