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