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