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