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