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