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