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