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