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