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