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