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