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