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