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