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