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