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