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