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