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