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