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