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