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