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